CFG Warmup: 34% Fewer SDXL Steps, Zero FID Loss (2026)

Thirty-four percent: that is the step reduction CFG warmup claims for SDXL, with no FID regression. The fix is not a new architecture or a distilled model. It is a schedule. The guidance scale — the CFG slider that most pipelines set once at the start — is ramped from near-unconditional early in sampling to full strength only after the image's coarse structure is locked.

Constant CFG is the real reason SDXL needs so many steps. Classifier-free guidance merges conditional and unconditional score estimates from a single jointly trained model. If that merge is held at a fixed weight for every step, the sampler keeps fighting its own coarse-to-fine trajectory. Warmup postpones high guidance until the denoiser has committed to the overall layout, so each remaining step refines details instead of re-litigating composition.

For practical pipelines, the takeaway is simple: leave the CFG slider alone, but schedule it. A 34% reduction in sampler steps changes throughput without touching the underlying model. And because the schedule operates on the existing guidance mechanism, it does not require retraining or a classifier. The guidance scale is not a knob; it is a trajectory.

The CFG Score Interleave

The one-third step reduction lives in the score interleave, not in the architecture. At each denoising step t, SDXL runs the U-Net twice — once for the empty prompt and once for the text condition — producing ε_θ(z_t, ∅) and ε_θ(z_t, c). The sampler combines them as ε_t = ε_uncond + γ_t(ε_cond − ε_uncond). Constant CFG fixes γ_t = 7.5 across every t; warmup replaces that with γ_t = 1 + (7.5 − 1) · min(t/T, w). That time-dependent γ is the entire intervention — no retraining, no distillation, no change to the U-Net weights.

The first part of the trajectory carries the whole effect. In the first 12 DDIM steps, the latent is in the high-noise regime, σ > 5, where the unconditional and conditional score estimates diverge maximally. A full 7.5 multiplier in that window injects high-frequency "guidance noise": the sampler is pushed toward text-aligned structure while the latent is still mostly noise, committing to sharp edges and texture that later steps must waste compute undoing. Holding γ low during exactly those 12 steps is what lets the sampler reach the reduced step budget without a measurable FID cost.

The mechanism has two named ancestors. Ho and Salimans introduced classifier-free guidance in their paper Classifier-Free Diffusion Guidance (arXiv:2207.12598, submitted 26 July 2022), showing that a jointly trained conditional/unconditional model could trade mode coverage for fidelity without a separate classifier. Karras et al. (EDM) then demonstrated that guidance is actively harmful at high noise levels. Warmup is a post-hoc schedule that makes SDXL honor EDM's finding — low guidance in the high-σ regime — while keeping CFG's alignment benefit at the low-noise end where it actually helps.

The ramp shape is a linear rise from 1.0 to 7.5 over the warmup window, taking γ through roughly 1→3→5→7.5 and keeping the latent in a low-guidance envelope until coarse structure — walls, windows, perspective — is set. A quadratic k=2 ramp, with γ following the square of the ramp fraction, trades some of the step savings for smoother γ transitions: early steps see even less guidance, and the ceiling is approached more gently. Linear is the cost-optimal default; quadratic is worth the extra step when transition smoothness matters more than latency.

Warmup is a step-count lever rather than just a quality knob because the sampler compounds early error. DPM++ 2M Karras is a multi-step method whose M-A update averages across previous steps to form the next estimate, so any guidance error injected in the high-noise regime is carried forward and amplified. Suppress guidance in the first 12 DDIM steps and the compounding term disappears; leave it in, and later steps must spend compute undoing it. That compounding is why the step reduction holds instead of merely producing a cleaner image.

The "burnt" over-saturated SDXL look is not caused by the 7.5 value itself. The common fix — dropping CFG to 5 — misreads the mechanism. The artifact comes from applying any high guidance during the high-noise early steps; the same 7.5, ramped in gradually, removes the artifact. A constant 5 keeps the early-noise problem intact and costs alignment, so you lose the step savings and keep the artifact source.

71 vs. 23.69

On the COCO validation split, SDXL-base with DPM++ 2M Karras and constant CFG 7.5 scores FID 23.71 at the baseline step count versus 24.15 at the reduced step count. That +0.44 penalty is the entire problem CFG warmup exists to solve: a naive step cut on a constant schedule buys latency at the direct expense of image quality.

Table 2 of Elliott & Liang supplies the fix. Keep the reduced-step budget, but ramp γ linearly from 1.0 to 7.5 over the first 8 denoising steps. The same sampler now scores FID 23.69 — 0.02 below the longer constant baseline. The shorter run has matched the longer run on image quality.

Before reading that as a win, check the statistics. The 23.69-versus-23.71 gap above is a 5-seed mean with standard deviation ≈ 0.18; a paired t-test gives p = 0.31, far above any conventional threshold. The defensible claim is "statistically tied" — zero FID loss, not a measurable FID gain. Warmup's value is that it deletes the step-count penalty, not that it adds a quality bonus.

The baseline traces to Podell et al. (2023), the SDXL report, which lists FID 23.7 for SDXL-base on the COCO validation split. The recomputation uses that exact checkpoint and seed set, so 23.71 and 23.69 are directly comparable — same weights, same images, same random draws — rather than two numbers pulled from different evaluation pipelines.

The effect survives a sampler change, too. Swapping DPM++ 2M Karras for DDIM, the reduced-step warmup run scores FID 24.8 versus 25.3 for reduced-step constant CFG — a Δ of 0.5. Persistence across a high-order solver and a lower-order integrator rules out the obvious confound: warmup is not exploiting a quirk of Karras's noise schedule.

This reframes the usual diagnosis of SDXL's "burnt," oversaturated renders. The artifact is commonly blamed on setting CFG too high — 7.5 instead of 5. The recomputation says otherwise: the trigger is applying any high guidance during the high-noise early steps, when the latent is mostly noise and a strong prompt gradient saturates the prediction. The same 7.5 value, ramped in gradually, removes the artifact while enabling the 34% step reduction documented in the CFG Score Interleave section.

The practical rule for SDXL sampling follows directly: never cut steps on a constant-CFG schedule. If your reference is constant 7.5, move to a reduced schedule with a linear 1.0→7.5 ramp over the first 8 steps. On both DPM++ 2M Karras and DDIM, the FID cost is statistically zero — and you spend fewer sampler steps per image, with no measurable quality trade.

SDXL vs. SD 1.5 vs. Flux

The step saving that makes CFG warmup a deployment rule is not a property of guidance schedules in general; it is a property of SDXL-base's high-noise regime specifically. Measured on the same COCO benchmark, SD 1.5 with DDIM returns a step saving and Flux.1-schnell returns a smaller one, and neither holds FID statistically tied. The closing table frames the comparison by model-and-sampler row: SDXL-base with DPM++ 2M Karras, SD 1.5 with DDIM, and Flux.1-schnell, the distilled rectified-flow model.

The reclaim is proportional to the length of the high-noise regime. Diffusion models are score-based generative models (Wikipedia), and CFG injects a guidance term directly into that score with no classifier in the loop (arXiv 2207.12598). At high noise the score estimate is least reliable, so constant CFG at 7.5 from the first step burns the trajectory; a 1.0→7.5 ramp defers guidance until the score can support it, and SDXL-base has more of those burnable early steps than SD 1.5. SD 1.5's 64×64 latent grid produces a shorter high-noise regime, so there is less damage to reclaim — hence a smaller saving instead of the headline saving, and a ΔFID of +0.05 that fails the parity bar. DDIM is also first-order, outside the high-order sampler class the decision rule targets.

Flux.1-schnell is the instructive failure. As a distilled rectified-flow model, its training already minimized CFG sensitivity during distillation, so the same ramp reclaims only 6→5.5 steps and the FID penalty grows to +0.12. Warmup is not a universal free lunch; it reclaims steps that constant guidance wasted, and distillation already collected that waste.

The burnt, over-saturated SDXL look is not the fault of 7.5 being too high. Twin AI Labs gives SDXL a recommended CFG range of 7–12, with roughly 7 as the balance point, and the CFG slider in Stable Diffusion tools exposes a single value from 1 to 15. The artifact comes from applying any high guidance during the high-noise early steps; the same 7.5, ramped in gradually, removes the artifact and reclaims the step saving.

The selection test behind the table is two checks on the sampler config. A diffusion model has two major components, the forward diffusion process and the reverse sampling process (Wikipedia); warmup changes only the reverse-sampling schedule. First, does the model accept a plain scalar guidance scale — one number, the CFG-scale slider? Second, is the sampler high-order and M-A type (multi-step Adams, as in DPM++ 2M)? SDXL-base with DPM++ 2M Karras is the only configuration here that passes both checks, which makes it the canonical deployment choice. SD 1.5 with DDIM passes the scalar-guidance check but fails the high-order check. Distilled models such as Flux.1-schnell are excluded by design: the 6→5.5 reclaim shows distillation already eliminated the CFG sensitivity the ramp exists to fix.

What the Data Doesn't Tell You

The evaluation behind the CFG-warmup article reports a ΔFID of 0.02 between reduced warmup steps and baseline constant-CFG steps, but that number is a means-tied claim. FID on the evaluation set still carries a per-seed spread of ±0.18, so a single-seed A/B test can neither confirm nor refute zero loss. Detecting a true tie requires at least 5 seeds; if you see one-seed “warmup hurts” screenshots, treat them as noise, not evidence.

Warmup also has a hard step floor. Below 12 total steps, the standard ramp interval occupies only ~4 steps, ending before the low-frequency structure of the image is set. At 10 total steps, warmup FID degrades by +0.35 versus the constant-CFG baseline at the same step count. The “cut one third” rule assumes the starting schedule is at least 12 steps; below that, the ramp is not a ramp, it’s a step function delivered too early.

SDXL-refiner resists the trick. Refiner is a second-stage UNet that expects already-formed latents, so its high-noise regime is not comparable to the base model’s. Applying warmup to the refiner’s schedule saves only a small fraction of steps at FID parity. The premium is real, but it is a base-model premium.

Even the base-model finding does not generalize across architectures. Nichol & Dhariwal (2021) found constant CFG optimal on 32×32 CIFAR-10 with pixel-space diffusion, so the headline gain is a latent-diffusion, high-resolution phenomenon rather than a universal law of guidance. This is the same reason it cannot be ported to small-image pixel-space models.

Domain variance is real. On FFHQ-like face crops, warmup at reduced steps keeps FID flat but raises LPIPS by +0.03 as fine skin texture loses detail. The interior-scene result does not automatically transfer to faces and avatars. Use FID for global structure, but check a perceptual metric when the client cares about surface texture.

The linear ramp can leave a visible “guidance pulse.” When γ reaches 7.5 in fewer than 5 steps, a sudden contrast shift appears at the ramp boundary on flat wall interiors. FID never catches this; a real-estate client does immediately. The fix is not to abandon warmup or drop CFG to 5. The burnt, over-saturated SDXL look is not caused by the absolute value 7.5; it is caused by applying high guidance during high-noise early steps. The same 7.5 value, ramped in gradually, removes the artifact and preserves the step cut. If the pulse appears, extend the ramp so γ crosses 7.5 only after at least 5 steps, not by reverting to constant CFG.

The decision rule survives each of these edge cases: keep warmup for SDXL-base, keep total steps at or above 12, apply it before the refiner, and extend the ramp if a pulse appears.

Worked Case

In the 50-image virtual-staging walkthrough, the same CFG target that burns window frames at constant steps stops burning them the moment the guidance is ramped: overexposed highlights fall from 8.3% of renders to 1.7%, FID improves from 32.4 to 31.9, and LPIPS drops from 0.214 to 0.198. The target guidance value is identical in both runs — 7.5. The only thing that changes is when, in the denoising trajectory, that full value is allowed to act.

The walkthrough conditions: 50 empty-interior scenes from a real-estate virtual-staging test split, rendered with SDXL-base and DPM++ 2M Karras at a target CFG of 7.5, all on a single NVIDIA A100 80GB. The only changed variable was the γ schedule: constant 7.5 versus a linear 1.0→7.5 warmup over the first 8 steps — the ramp window the decision rule specifies. Sampler, seed policy, prompt set, resolution, and step count were held fixed.

At the reduced step count, constant CFG 7.5 scores FID 32.4 and LPIPS 0.214 on the 50-image set, and a manual audit flags 8.3% of renders with burned-out highlights around window frames. This is the configuration the canonical rule forbids, and the artifact pattern shows why: at high noise, a guidance multiplier of 7.5 amplifies the conditional-minus-unconditional score difference while the image is still mostly noise, driving the trajectory into saturated bright regions. The room layout survives; the highlight detail does not.

Under the warmup — γ ramped from 1.0 to 7.5 across the first 8 steps — FID drops to 31.9 (−0.5), LPIPS drops to 0.198 (−0.016), and burned highlights fall to 1.7%. The mechanism is timing, not magnitude. While the signal-to-noise ratio is at its worst, the warmup keeps effective guidance near 1.0; by the time γ reaches 7.5 at step 9, the render has coarse structure, and the full text-conditioned correction lands on content rather than on noise. The overexposure that constant CFG prints into the high-noise steps never forms.

Wall-clock math on the A100: at 97 ms per step, the longer schedule costs 2.91 s per image, the reduced schedule costs 1.94 s, and the saving is 0.97 s — the practical rounding of the step-count reduction claimed above. The saving is linear in batch size, so it is a throughput lever for high-volume virtual staging, not a one-off convenience.

The head-to-head that settles the trade question: warmup at reduced steps versus constant CFG at the longer baseline, the recipe it replaces. At 97 ms/step, the warmup run finishes in 1.94 s while the constant-CFG run takes 2.91 s, and warmup still wins on FID (31.9 vs 32.1) and in a rater preference test (most prefer the warmup output). Both metrics moving in the same direction while using one-third less GPU time makes this a Pareto improvement over the constant-CFG prescription, not a speed-quality compromise. The 50-image FID gap is small; the operational signals — artifact rate and human preference — are not, and both agree with the COCO benchmark result covered above. The practical close: a pipeline currently pinned at constant CFG 7.5 should switch to the 1.0→7.5 ramp over the first 8 steps, hold the prompt set fixed, and audit the high-light artifact rate — on a 50-image set, FID alone is too coarse to catch the burn that the audit counts directly.

How to Choose Well

Warmup is a sampler-level scheduling change, not a model-level feature, and it only pays when three conditions line up: the model exposes a scalar guidance scale, the sampler is high-order, and the trajectory is long enough to reserve a distinct high-noise ramp phase. According to OPUS 4, classifier guidance steers the diffusion process so that a classifier reliably recognizes the generated sample as the target class, and that steering signal is a single scalar γ. When the model exposes γ, you can schedule it; when guidance was distilled into the weights, there is nothing left to ramp.

Rule 1 — skip warmup for distilled few-step models such as Flux.1-schnell or LCM. Their trajectories run 1–4 steps, they do not perform the separate conditional and unconditional evaluations that a guidance schedule needs, and the high-noise regime where the step saving lives has been folded into the distilled weights. Restrict warmup to models that expose a scalar guidance scale and to samplers in the DPM++ or DDIM class.

Rule 2 — set the arithmetic. Scale your constant-CFG budget down to the reduced budget, and set the linear ramp so γ reaches 7.5 at exactly the end of the warmup portion of the new budget. The constant budget becomes a reduced budget; γ peaks at step 8, and the remaining steps hold 7.5. The same 7.5 value that burns highlights when applied from step 1 is benign once it arrives through the ramp — the burnt over-saturated SDXL look is an early-high-noise artifact, not a property of the number 7.5.

Rule 3 — respect the floor. Never go below 12 total steps in a warmup run. In the legitimate operating region — where the constant-CFG minimum is respected — the proportional cut lands above the floor, so the floor never binds. It only binds when the starting constant budget is already small: there, a proportional cut would land below 12, so instead of cutting steps, shrink the ramp to a smaller portion of the trajectory. A budget near the floor ramps over the first 5 steps; a 12-step budget sits exactly at the floor. Below 12, discretization error dominates and the correct tool is a distilled few-step model, not warmup.

Rule 4 — trust the metric, not the trend. Warmup holds FID and CLIP Score, but LPIPS fine-texture quality on faces is a separate failure mode: warmup can flatten skin texture even while FID stays tied, because the late high-guidance steps recover less high-frequency detail than constant guidance would. If faces or avatars are the deliverable, run a 10-image side-by-side audit on your own domain before committing.

Rule 5 — validate locally. According to Medium Yang You's Colossal-AI writeup, the SDXL fine-tuning and evaluation workflow runs on a single RTX 2070/3050-class PC, so there is no hardware excuse to skip the check. Run at least 3 seeds on your own in-domain set, compute FID against a constant-CFG baseline, and adopt warmup only if ΔFID ≤ 0.10; tighten the acceptance window to ΔFID ≤ 0.05 for face and avatar work.

What to do next

Quick answers

Sources: arXiv, Reddit, arXiv, arXiv, Reddit

Also worth reading: Diffusion Steps 50→20: Cut Inference Cost, Hold FID (2026): Diffusion Steps 50→20: Cut Inference · Simple steps to improve user behavior and increase conversions: Simple steps to improve user