Image generators built on diffusion models start from pure noise and remove it step by step. Earlier work finds that these models commit to coarse structure first and fine detail last. That finding has turned into a working rule: anything about layout, including how many objects appear and where, is settled in the first few steps. Several training-free fixes for multi-object prompts act only on those early steps. This proposal argues the rule is a special case. Whether an object is "coarse" or "fine" depends on its size on the canvas. In a crowded scene, each of fifty apples is a small, high-frequency structure, so the step at which the model commits to each apple's existence should come later, in a predictable way. If that holds, the early-only fixes are acting at the wrong time in exactly the dense scenes where generators fail. That would partly explain why they break down beyond a handful of entities.
The core claim is a quantitative law, and it can be tested cheaply. The step at which an object is committed should be predictable from the object's size and from the power spectrum of the model's latent images. The power spectrum describes how image energy is spread across spatial frequencies. The proposal has two parts. First, measure this "commitment time" per object across a controlled sweep of scene density in two generator families. Second, show that moving existing object-level guidance into the predicted window improves counting and reduces missing objects in dense prompts. Simply applying the same guidance at every step, or tuning the sampling schedule, should not give the same gain.
Core Claim
Spectral progression is usually explained through the forward noising process. Pixel-level white noise drowns high spatial frequencies before low ones, so the reverse process rebuilds low frequencies first (Chung et al., Gao et al.). Natural images follow a power law, with energy falling off as $1/f^\beta$ in spatial frequency $f$, as FreeDiff notes. Take a variance-preserving noising process $x_t = \alpha_t x_0 + \sigma_t \epsilon$. Here $x_0$ is the clean latent, $\epsilon$ is white Gaussian noise, and $\alpha_t, \sigma_t$ are the signal and noise scales at step $t$. The per-frequency signal-to-noise ratio is then approximately $\alpha_t^2 A f^{-\beta} / \sigma_t^2$, where $A$ is the spectrum's amplitude. Suppose an object of diameter $d$ (in latent pixels) becomes individuated once frequencies near $c/d$ become recoverable, meaning their signal-to-noise ratio crosses some threshold $\tau$. Here $c$ is a constant tied to how many cycles across an object are needed to separate it from its neighbours. Writing $\lambda = \log(\alpha_t^2/\sigma_t^2)$ for the log signal-to-noise ratio of the sampler, the predicted commitment point is
$$\lambda^*(d) = \lambda_0 + \beta \log(1/d),$$
where $\lambda_0 = \log \tau - \log A + \beta \log c$ collects the constants. The prediction is linear in $\log(1/d)$, and its slope is not a free parameter: it is the measured spectral exponent $\beta$ of that model's latent space. Large isolated objects get committed at high noise, which matches the "layout is early" observations of ELA and Yi et al.. Small packed objects get committed later, inside the window that current methods either leave untouched or explicitly drop guidance from.
The law is simplistic. Learned denoisers are not linear filters, and objects carry content at many frequencies. That is why the slope test is the centerpiece rather than an assumption. If commitment turns out flat in object size, the existing early-only practice is vindicated and the proposal fails cleanly.
Relation to Prior Work
Three groups of papers shape this proposal. The first motivates it by establishing time-structured generation but treating time as global. Beta Sampling uses Fourier analysis along the sampling path to concentrate steps at the start and end. Its own stated limitation is that the allocation is computed offline per dataset and does not adapt to samples with unusual spectra. DyPE schedules positional-encoding stretching over time to reach 16-megapixel images. It scales canvas size, not the number of objects within a fixed canvas. Yi et al. show that text conditioning matters mainly in the early shape-forming phase and can be dropped late for a speedup of more than 25%. We predict that this truncation becomes harmful exactly when the prompt asks for many small objects. That is a direct, testable tension with their result, and the outcome is open.
The second group supplies the interventions we retime. ELA sharpens and suppresses cross-attention, the maps that tie each prompt word to image regions, only during early steps. It reports degradation at four or more entities. Attend-and-Excite, which we know only through ELA's comparisons, applies a similar idea. AnyMS isolates subjects by cropping and merging latent regions inside user-given boxes, statically across steps. SGG-IG applies a scene-graph alignment loss uniformly over denoising. We reuse their guidance losses unchanged and alter only when they act. This keeps the contribution about timing.
The third group defines the density regime and constrains the design. VisualOverload, VISER and LVLM-COUNT show that vision-language models collapse on counting and binding as density rises. LVLM-COUNT also shows that naive grid tiling cuts objects in half. These papers concern recognition, not generation. We use them in two ways: they motivate density as the axis of difficulty, and they warn that our automatic object counter will itself be error-prone at high counts. The closest existing work is SpecFlow. It schedules low-then-high frequency coefficients in a flow-matching visual scratchpad and admits a resolution ceiling in dense scenes. It schedules by a global frequency index. We instead predict the timing of each object from that object's size, in ordinary image generators.
Research Program
The first stage is measurement. We build a density sweep of prompts. Each pairs a single noun or two nouns with an explicit count from 1 to about 60 (for example "forty-two marbles on a table"), plus multi-noun prompts in the style of ELA's animal pairings. We generate with Stable Diffusion, the U-Net family ELA targets, and with FLUX, the transformer family DyPE uses. At every step we decode the model's current guess of the clean image. We segment objects in the final image with a detector-plus-segmenter. An object's commitment step is the earliest step after which its mask in the decoded guess keeps overlap above 0.5 with its final mask, without later disappearing.
Mask stability is correlational, so we add a causal probe. We re-inject fresh noise into a single object's region at step $t$ and continue sampling. The commitment step is the latest $t$ at which this reliably removes or merges the object. Separately, we estimate $\beta$ from the radially averaged power spectrum of each model's latents on natural images. We then fit $\lambda^*$ against $\log(1/d)$ across objects and test whether the slope matches $\beta$ for each model. The two families should have different latent spectra, so they make different predictions.
The second stage is intervention. We call the method scale-timed guidance. Given a prompt with count $N$, an expected object diameter $d \approx \sqrt{\text{canvas area}/N}$ (or a per-word estimate for mixed scenes) gives a predicted window centred on $\lambda^*(d)$. Inside that window we apply an existing guidance loss: ELA's concentrate-and-attenuate loss, or a count-peak loss. The count-peak loss rewards the cross-attention map of the counted noun for having $N$ separated peaks at the spatial scale $d$. Outside the window we apply nothing. For mixed scenes with objects of different sizes, each word gets its own window. Holding the number of guided steps fixed across all variants makes compute comparable.
Baselines
The naive reference point is the unmodified sampler of each model at the same step count, with no guidance. It tells us how badly count fidelity falls with density in the first place. No reported result found on Lacuna for count accuracy of text-to-image models at large requested counts, so we measure this ourselves.
The strongest existing method on this question is ELA. It targets missing and blended entities, is training-free, and already uses an early-only timing rule, which makes it the natural foil. ELA reports a BLIP text–text similarity of 0.7964 on Animal-Animal prompts, against 0.7571 for plain Stable Diffusion, and a 34.02% human best-choice rate against 18.05% for Attend-and-Excite (ELA). We run ELA with its published early window, the same seeds and prompts, and Stable Diffusion as the base. Before scaling up, we reproduce its Animal-Animal figure to confirm the implementation. Beating it means two things. First, our timed version must match its Animal-Animal score at low entity counts, where both windows should coincide. Second, it must significantly lower counting error and missing-object rate at 8 or more entities, under a human-verified count. Attend-and-Excite is run the same way as a second guidance baseline.
The layout baseline is AnyMS crop-and-merge. Its user boxes are generated automatically by placing $N$ boxes of size $d$ with a simple packing routine, because it reports 49.75 mean intersection-over-union for layout adherence and is the method most likely to win on counts by brute force (AnyMS). The schedule baseline is Beta Sampling, with its $\alpha$ tuned per density bucket on a held-out prompt split, using the same tuning budget we give our window width.
Three ablations isolate the key ingredient, timing. The first applies the same guidance with the same number of guided steps placed at random positions along the path. The second applies guidance at all steps, which costs more and is reported with its cost. The third uses a single window tuned per density bucket by grid search instead of predicted from $\beta$. The third ablation separates "timing matters" from "our law predicts the timing."
Why not just…?
Why not just apply the guidance at every step? If commitment time does not matter, always-on guidance should match or beat any window, and our claim reduces to "more guidance helps." This is a real threat for count accuracy. Its known cost is that late-step semantic pressure can distort textures and backgrounds. That is the reason FreeDiff restricts its filtering to a response window and reports lower background distortion than Prompt-to-Prompt (11.14 against 11.83 background LPIPS). The all-steps ablation, scored on both count error and image quality, settles it. If it equals the timed window at matched guided-step count, we drop the intervention claim and keep only the measurement study.
Why not just give the model boxes? Layout-conditioned methods like AnyMS sidestep timing by fixing where each object goes. With automatically generated boxes they may count well. Boxes impose an artificial grid-like arrangement, need a box per object (impractical for "a crowd" or mixed sizes), and say nothing about why unconditioned sampling fails. We run AnyMS with packed boxes and report it honestly. If it dominates on count error, the proposal's value narrows to the box-free setting and to the explanatory law, and we will say so.
Why not just generate at higher resolution so each object is larger? By our own law, enlarging $d$ moves commitment earlier, so this should help. It is a legitimate alternative, not a strawman. But DyPE shows that pushing generators past their trained resolution produces tiling and repetition without careful positional rescheduling, which seems likely to duplicate objects in a counting task. Attention cost also grows quadratically. We include a DyPE-at-2× resolution arm. The law makes a sharp prediction here: at fixed $N$, doubling resolution should shift measured commitment by $\beta \log 2$ in log signal-to-noise. Confirming that would strengthen the mechanism even if resolution scaling competes as a fix.
Why not just tune the sampling schedule? Beta Sampling concentrates steps at both ends and helps quality at low step counts. It allocates steps, though; it does not target any particular object's commitment, and its parameters are fit per architecture rather than per scene. The density-tuned Beta baseline tests whether reallocating steps alone captures the effect.
Decisive Checks
The first check is the slope test. Across the density sweep, the fitted slope of commitment log signal-to-noise against $\log(1/d)$ should be positive and fall within the confidence interval of the separately measured latent $\beta$, in both Stable Diffusion and FLUX. A flat slope, meaning everything committed early regardless of size, falsifies the proposal and supports early-only methods. A positive slope that differs from $\beta$ means timing matters but the spectral explanation is wrong.
The second check is an interaction. Moving ELA's guidance to the predicted window should leave low-count prompts unchanged and improve high-count prompts. The benefit should grow with $N$, and the predicted window should beat the random-placement ablation. A uniform benefit across all densities would point to a generic tuning effect rather than scale-dependent timing.
The third check tests Yi et al.'s truncation. Dropping text conditioning in the late phase should cost little for sparse prompts, as they report, but should measurably raise missing-object rates for dense ones, with the cutoff at which harm starts tracking $\lambda^*(d)$.
Counts are measured with a detector-plus-segmenter. The counter is calibrated against human counts on a 500-image subset, because LVLM-COUNT's own pipeline still leaves a mean absolute error of 17.86 on FSC-147 with GPT-4o (LVLM-COUNT). Any claimed gain must hold under human counts, not just under the automatic counter. As a secondary use, the human-verified dense images with known counts and known commitment times become controlled stimuli. Later work can use them to test whether the scenes that generators commit late are also the ones vision-language models miscount, linking back to VisualOverload.
References
- Progressive Deblurring of Diffusion Models for Coarse-to-Fine Image Synthesis
- TFD: Spectrally Guided Time–Frequency Diffusion Model For Time Series Imputation
- FreeDiff: Progressive Frequency Truncation for Image Editing with Diffusion Models
- Easing Concept Bleeding in Diffusion via Entity Localization and Anchoring
- Towards Understanding the Working Mechanism of Text-to-Image Diffusion Model
- Beta Sampling is All You Need: Efficient Image Generation Strategy for Diffusion Models Using Stepwise Spectral Analysis
- DyPE: Dynamic Position Extrapolation for Ultra High Resolution Diffusion
- AnyMS: Bottom-up Attention Decoupling for Layout-guided and Training-free Multi-subject Customization
- Scene Graph-Grounded Image Generation
- VisualOverload: Probing Visual Understanding of VLMs in Really Dense Scenes
- Visual Structures Help Visual Reasoning: Addressing the Binding Problem in LVLMs
- LVLM-Count: Enhancing the Counting Ability of Large Vision-Language Models
- Spectral-Progressive Thought Flow for Lightweight Multimodal Reasoning