Classifier-Free Guidance

Classifier-free guidance (CFG) makes a conditional diffusion model follow its condition more strongly than plain conditional sampling does. One network is trained to predict the noise both with the condition, a class label or a caption, and without it; at every sampling step the two predictions are combined so that the step moves past the conditional prediction, away from the unconditional one. The resulting images are more typical of the class or closer to the prompt, and less varied. Ho and Salimans (2022) introduced the method as a replacement for classifier guidance (Dhariwal & Nichol, 2021), which needs a separate classifier trained on noisy images.

This article uses the notation of the diffusion model article: noisy image $x_t$, noise schedule $\bar\alpha_t$, conditional noise predictor $\epsilon_\theta(x_t, t, y)$ for a condition $y$, and score $s_\theta = -\epsilon_\theta / \sqrt{1 - \bar\alpha_t}$. Ho and Salimans write $c$ for the condition and index noise levels by log signal-to-noise ratio; their equations are translated here.

Purpose

GANs and likelihood models trade diversity for per-sample quality at sampling time, through BigGAN’s truncation trick or low-temperature sampling. Ho and Salimans note that the obvious diffusion analogues, scaling the score or reducing the noise added at each step, give blurry, low-quality samples (citing Dhariwal & Nichol). Guidance reweights the conditional distribution toward images easy to recognize as the condition. On class-conditional ImageNet this traded the Fréchet Inception Distance (FID) against the Inception Score (IS) along a curve like BigGAN’s truncation curve, and in text-to-image models it trades image–text alignment against image fidelity (Saharia et al., 2022).

When to Use It

Use guidance when samples must clearly show their condition and some loss of variety is acceptable, as in class-conditional benchmarks and text-to-image generation. CFG suits conditions that are hard to classify, such as free text, an advantage GLIDE’s authors point out. It needs a model trained with the condition sometimes dropped (with a few classes of known frequency, Ho and Salimans note, the unconditional score can instead be obtained from the conditional ones, one pass per class). In our view, strong guidance is a poor choice when coverage of the data matters, for example when generated images will train or evaluate other models.

How It Works

Classifier guidance

Dhariwal and Nichol (2021) trained a classifier $p_\phi(y \mid x_t, t)$ on noisy images and shifted the mean of each reverse step along its gradient: $x_{t-1} \sim \mathcal{N}(\mu + s\, \Sigma\, \nabla_{x_t} \log p_\phi(y \mid x_t),\ \Sigma)$ (their Algorithm 1). In noise-prediction form (their Eq. 14, with the scale $s$ that their Algorithm 2 takes as input),

$$\hat\epsilon(x_t) = \epsilon_\theta(x_t, t) - s \sqrt{1 - \bar\alpha_t}\, \nabla_{x_t} \log p_\phi(y \mid x_t),$$

which corresponds to the score of $p_t(x_t)\, p_\phi(y \mid x_t)^s$; for $s > 1$ the renormalized $p_\phi(y \mid x)^s$ is sharper than the classifier, as they note. With an unconditional ImageNet model they needed $s > 1$: at $s = 1$ the classifier gave the intended classes around 50% probability, yet the samples did not visually match them. In their Table 4 (ImageNet $256 \times 256$, arXiv v4), guiding the conditional model at $s = 1$ improved FID from 10.94 to 4.59 and precision from 0.69 to 0.82, while recall fell from 0.63 to 0.52; at $s = 10$, FID rose to 9.11 and recall fell to 0.32. The cost is a second network whose gradient is needed at every step.

Conditioning dropout and the guided prediction

Ho and Salimans drop the classifier. During training the condition is replaced by a null token $\varnothing$ with probability $p_{\text{uncond}}$, so a single network learns both $\epsilon_\theta(x_t, t, y)$ and $\epsilon_\theta(x_t, t) := \epsilon_\theta(x_t, t, \varnothing)$ (their Algorithm 1). At sampling time each step uses (their Eq. 6)

$$\tilde\epsilon = (1 + w)\, \epsilon_\theta(x_t, t, y) - w\, \epsilon_\theta(x_t, t) = \epsilon_\theta(x_t, t, y) + w \big[\epsilon_\theta(x_t, t, y) - \epsilon_\theta(x_t, t)\big]$$

in place of $\epsilon_\theta$ in any sampler (Algorithm 2). With $w = 0$ this is ordinary conditional sampling; $w > 0$ extrapolates along the difference between the two predictions.

The implicit classifier

By Bayes’ rule, $p_t(y \mid x_t) \propto p_t(x_t \mid y) / p_t(x_t)$, so with exact noise predictions $\epsilon^\ast$,

$$\nabla_{x_t} \log p_t(y \mid x_t) = -\frac{1}{\sqrt{1 - \bar\alpha_t}} \big[\epsilon^\ast(x_t, t, y) - \epsilon^\ast(x_t, t)\big].$$

With exact scores, then, CFG is classifier guidance of the conditional model with scale $w$, using the classifier implied by the generative model itself; the guided score is that of $p_t(x_t \mid y)\, p_t(y \mid x_t)^w \propto p_t(x_t \mid y)^{1+w}\, p_t(x_t)^{-w}$. Ho and Salimans stress that this is a motivation, not an identity for trained networks: because the networks are unconstrained, $\epsilon_\theta(x_t, t, y) - \epsilon_\theta(x_t, t)$ need not be the gradient of any classifier, so a CFG step is not an adversarial attack on one. Their own summary of the mechanism is that guidance raises the conditional likelihood of the sample while lowering its unconditional likelihood.

Even with exact scores, the guided sampler does not sample $p_0(x \mid y)\, p_0(y \mid x)^w$. The tilted densities at different noise levels are not related by the forward process, and Bradley and Nakkiran (2024) show by counterexample that neither DDPM nor DDIM sampling with CFG produces that distribution.

Two conventions for the scale

In Ho and Salimans’ convention $w = 0$ means no guidance. GLIDE (Nichol et al., 2022, §2.3) writes $\hat\epsilon = \epsilon_\theta(x_t \mid \varnothing) + s\, (\epsilon_\theta(x_t \mid y) - \epsilon_\theta(x_t \mid \varnothing))$ with $s \ge 1$; Imagen (Saharia et al., 2022, Eq. 2) writes $w\, \epsilon_\theta(z_t, c) + (1 - w)\, \epsilon_\theta(z_t)$, where its $w = 1$ disables guidance; and the CompVis Stable Diffusion sampler computes e_t_uncond + scale * (e_t - e_t_uncond), skipping the unconditional pass when the scale is 1. All three are the same formula with

$$s = 1 + w.$$

As of October 2026, the Stable Diffusion repository’s sampling script defaults to a scale of 7.5, which is $w = 6.5$ in Ho and Salimans’ convention, and the diffusers library’s guidance_scale, also 7.5 by default, is $s$, with 1 meaning no guidance.

How to Apply It

Training. Ho and Salimans found $p_{\text{uncond}} = 0.1$ and $0.2$ about equally good on ImageNet $64 \times 64$, and $0.5$ worse across the whole FID–IS frontier. GLIDE fine-tuned its base model with 20% of captions replaced by the empty sequence; Imagen zeroed the text embeddings with 10% probability; and as of October 2026 the Stable Diffusion README states that its v1.3 and v1.4 checkpoints were trained with 10% of text conditioning dropped. The null condition may be a learned null class, an empty caption or zeros.

Sampling. Evaluate the network on $(x_t, y)$ and $(x_t, \varnothing)$, as one doubled batch in the CompVis sampler, form $\tilde\epsilon$, and take the sampler’s usual step.

Negative prompts. In the diffusers Stable Diffusion pipeline the unconditional branch encodes an empty string, and a negative_prompt replaces it, giving $\epsilon_{\text{neg}} + s\, (\epsilon_y - \epsilon_{\text{neg}})$. In our reading, with exact scores the extra term corresponds to the gradient of $\log p_t(y \mid x_t) - \log p_t(\text{neg} \mid x_t)$, pushing samples toward the prompt and away from the negative prompt, with no retraining.

Large scales. Imagen’s authors traced the saturated, unnatural images produced at high guidance weights to a train–test mismatch: the predicted clean image $\hat x_0$ leaves the $[-1, 1]$ training range, and the sampler compounds the error. Clipping $\hat x_0$ to $[-1, 1]$ (static thresholding) prevented blank images but still over-saturated. Dynamic thresholding sets a threshold $\tau$ to a percentile of $|\hat x_0|$ at each step and, when $\tau > 1$, clips $\hat x_0$ to $[-\tau, \tau]$ and divides by $\tau$ (Saharia et al., 2022, §2.3), with $p = 99.5$ in an example figure (Fig. A.10, arXiv v1). It gave better photorealism and text alignment at large weights.

A toy example on 8×8 shapes

Three classes of $8 \times 8$ images, a plus sign, an X and a square outline with prototype pixels $\pm 1$, are each a Gaussian mixture of a faint, a medium and a full-contrast copy of the prototype, $x_0 = a\, \mu_k + 0.3\, \xi$ with $a \in \{0.05, 0.4, 1\}$. Faint images of different classes overlap. Every noisy marginal is again a known mixture, so exact scores replace trained networks. The code checks the implicit-classifier identity by finite differences, runs DDPM ancestral sampling with $\tilde\epsilon$, and reports the mean Bayes-classifier confidence $p(y \mid x_0)$ in the intended class, the share of samples nearest each contrast level, the mean contrast (1 for the prototype) and the within-class variance summed over pixels. It then estimates the same statistics for $p(x \mid y)\, p(y \mid x)^w$ by importance sampling.

import sys
import numpy as np

T = 1000
beta = np.linspace(1e-4, 0.02, T)              # linear schedule of Ho et al. (2020)
alpha = 1 - beta
ab = np.cumprod(alpha)

# Three classes of 8x8 shape images in [-1, 1]: plus sign, X, square outline.
yy, xx = np.mgrid[:8, :8]
masks = [(abs(yy - 3.5) < 1.5) | (abs(xx - 3.5) < 1.5),
         (abs(yy - xx) < 1) | (abs(yy + xx - 7) < 1),
         ((yy == 1) | (yy == 6) | (xx == 1) | (xx == 6)) & (yy >= 1) & (yy <= 6) & (xx >= 1) & (xx <= 6)]
proto = np.array([np.where(m, 1.0, -1.0).ravel() for m in masks])   # (3, 64) class prototypes

# Each class is a Gaussian mixture of a faint, a medium and a full-contrast copy of
# its prototype, x0 = a * proto_k + 0.3 * noise with a in {0.05, 0.4, 1}, equal weights.
amps = np.array([0.05, 0.4, 1.0])
K, A, D, s2 = 3, 3, 64, 0.3 ** 2
means = (amps[None, :, None] * proto[:, None, :]).reshape(K * A, D)
cls = np.repeat(np.arange(K), A)               # class of each mixture component

def log_comp(x, t):
    """log of (weight x density) of each component of the noisy marginal p_t (t = 0: clean)."""
    a = ab[t - 1] if t > 0 else 1.0
    v = a * s2 + 1 - a                         # component k: N(sqrt(a) m_k, v I)
    d2 = ((x[:, None, :] - np.sqrt(a) * means[None]) ** 2).sum(-1)
    return np.log(1 / (K * A)) - d2 / (2 * v) - D / 2 * np.log(2 * np.pi * v), a, v

def scores(x, t, c):
    """Exact conditional score grad log p_t(x|c) and unconditional score grad log p_t(x)."""
    L, a, v = log_comp(x, t)
    def score_from(Lm):
        r = np.exp(Lm - Lm.max(1, keepdims=True))
        r /= r.sum(1, keepdims=True)
        return -(x - np.sqrt(a) * (r @ means)) / v
    return score_from(np.where(cls[None] == c[:, None], L, -np.inf)), score_from(L)

def class_post(x, t=0):
    """Bayes posterior p_t(c|x) of the exact model, (n, K)."""
    L = log_comp(x, t)[0]
    Lk = np.stack([np.logaddexp.reduce(L[:, cls == k], 1) for k in range(K)], 1)
    return np.exp(Lk - np.logaddexp.reduce(Lk, 1, keepdims=True))

# 1) Implicit classifier: s_c - s_u equals grad_x log p_t(c|x) (central differences).
rng = np.random.default_rng(0)
for t in [100, 500]:
    x = rng.standard_normal((4, D))
    c = np.array([0, 1, 2, 0])
    sc, su = scores(x, t, c)
    fd = np.zeros_like(x)
    for j in range(D):
        e = np.zeros(D); e[j] = 1e-5
        fd[:, j] = (np.log(class_post(x + e, t)[np.arange(4), c])
                    - np.log(class_post(x - e, t)[np.arange(4), c])) / 2e-5
    print(f"t={t}: max |(s_c - s_u) - grad log p_t(c|x)| = {np.abs(sc - su - fd).max():.1e}")

# 2) Ancestral sampling (Ho et al., Algorithm 2) with the guided noise prediction
#    eps~ = (1 + w) eps(x_t, t, c) - w eps(x_t, t), eps = -sqrt(1 - ab_t) * score.
def sample(c, w, rng):
    x = rng.standard_normal((len(c), D))
    for t in range(T, 0, -1):
        sc, su = scores(x, t, c)
        eps = -np.sqrt(1 - ab[t - 1]) * ((1 + w) * sc - w * su)
        z = rng.standard_normal(x.shape) if t > 1 else 0.0
        x = (x - beta[t - 1] / np.sqrt(1 - ab[t - 1]) * eps) / np.sqrt(alpha[t - 1]) \
            + np.sqrt(beta[t - 1]) * z
    return x

def stats(x, c, wt=None):
    wt = np.full(len(c), 1 / len(c)) if wt is None else wt
    conf = wt @ class_post(x)[np.arange(len(c)), c]          # classifier confidence
    near = ((x[:, None, :] - means[None]) ** 2).sum(-1).argmin(1) % A
    share = np.array([wt[near == a].sum() for a in range(A)])
    return conf, share

seed = int(sys.argv[1]) if len(sys.argv) > 1 else 0
c = np.repeat(np.arange(K), 300)                              # 300 samples per class
print(f"\nguided sampling, seed {seed}, 900 samples per w")
print("    w   conf  faint  medium  full  contrast  within-class var")
for w in [0, 0.5, 1, 2, 4, 8]:
    x = sample(c, w, np.random.default_rng(seed))
    conf, share = stats(x, c)
    contrast = np.mean((x * proto[c]).sum(1) / D)             # 1 = prototype contrast
    var = np.mean([x[c == k].var(0).sum() for k in range(K)])  # summed over 64 pixels
    print(f"{w:5.1f}  {conf:.3f}  {share[0]:.3f}  {share[1]:.3f}  {share[2]:.3f}"
          f"   {contrast:.3f}     {var:6.2f}")

# 3) The tilted target p(x|c) p(c|x)^w at t = 0, by importance sampling from p(x|c).
rng = np.random.default_rng(1)
n = 20000
cc = np.repeat(np.arange(K), n)
x0 = means[cc * A + rng.integers(0, A, len(cc))] + np.sqrt(s2) * rng.standard_normal((len(cc), D))
p_c = class_post(x0)[np.arange(len(cc)), cc]
print("\ntilted target p(x|c) p(c|x)^w at t = 0 (importance sampling)")
print("    w   conf  faint  medium  full")
for w in [0, 0.5, 1, 2, 4, 8]:
    wt = np.concatenate([p_c[cc == k] ** w / (p_c[cc == k] ** w).sum() for k in range(K)]) / K
    conf, share = stats(x0, cc, wt)
    print(f"{w:5.1f}  {conf:.3f}  {share[0]:.3f}  {share[1]:.3f}  {share[2]:.3f}")

Output:

t=100: max |(s_c - s_u) - grad log p_t(c|x)| = 4.4e-09
t=500: max |(s_c - s_u) - grad log p_t(c|x)| = 1.6e-09

guided sampling, seed 0, 900 samples per w
    w   conf  faint  medium  full  contrast  within-class var
  0.0  0.864  0.378  0.307  0.316   0.457      15.79
  0.5  0.951  0.197  0.374  0.429   0.590      14.78
  1.0  0.979  0.118  0.334  0.548   0.689      13.81
  2.0  0.997  0.026  0.240  0.734   0.834      10.83
  4.0  1.000  0.002  0.102  0.896   0.940       7.91
  8.0  1.000  0.000  0.032  0.968   0.984       6.45

tilted target p(x|c) p(c|x)^w at t = 0 (importance sampling)
    w   conf  faint  medium  full
  0.0  0.873  0.335  0.334  0.331
  0.5  0.915  0.277  0.363  0.360
  1.0  0.939  0.238  0.383  0.379
  2.0  0.963  0.188  0.408  0.404
  4.0  0.981  0.135  0.435  0.431
  8.0  0.992  0.087  0.459  0.454

The conditional-minus-unconditional score matches the finite-difference gradient of $\log p_t(y \mid x_t)$ to about $10^{-9}$, the implicit-classifier identity. Without guidance the sampler reproduces the data, about a third of the samples at each contrast level, with confidence 0.864 because faint images are ambiguous. As $w$ grows, samples move toward the full-contrast prototype: at $w = 4$, 89.6% are nearest the prototype, the confidence rounds to 1.000 and the within-class variance falls from 15.79 to 7.91, approaching the $64 \times 0.09 = 5.76$ left by the within-copy noise. The script takes the seed as an argument; with seeds 1 and 2 the prototype share at $w = 4$ was 0.923 and 0.918.

The tilted target differs. Reweighting by $p(y \mid x)^w$ removes only faint images and splits their mass evenly between the medium and full copies, which are already classified almost surely. The guided sampler favors the full copy; in our reading, because medium copies are still confusable at high noise levels, where guidance also acts. It is an instance of the gap Bradley and Nakkiran describe.

Variants

• CLIP guidance replaces the classifier with a CLIP model trained on noised images; in GLIDE’s human evaluation on MS-COCO validation prompts, CFG at scale 3.0 was preferred over CLIP guidance for both photorealism and caption similarity (Nichol et al., 2022, Table 1).
• Guided distillation. Meng et al. (2023) train a student to match the guided teacher’s prediction for a range of $w$, with $w$ as an extra input, then progressively distill it to few steps; they report images visually comparable to the original model’s in 4 steps on ImageNet $64 \times 64$ and CIFAR-10, and high-fidelity images in 1 to 4 steps for latent models such as Stable Diffusion. The student needs one evaluation per step instead of two.

Best Practices

• Report the scale with its convention ($w$ or $s = 1 + w$).
• Sweep the scale for the metric that matters; Ho and Salimans’ best FID came at small $w$ and their best IS at $w = 4$.
• At large scales, threshold $\hat x_0$ in pixel-space samplers, as Imagen does.

Pitfalls

• Saturation. Ho and Salimans note saturated colors in strongly guided ImageNet samples at $w = 3$ (their Fig. 3), and Imagen’s authors report highly saturated, unnatural images at large weights without dynamic thresholding.
• Lost diversity. Ho and Salimans caution that less diverse samples can harm deployed systems in which parts of the data are underrepresented.
• Double compute. Each step evaluates the network twice. Ho and Salimans note that at 128 steps, the cost-matched comparison with ADM-G’s roughly 256, their FID was worse than ADM-G’s.

Evidence and Impact

Ho and Salimans’ class-conditional ImageNet tables (arXiv v1) show the trade-off. At $64 \times 64$ with $p_{\text{uncond}} = 0.1$ (Table 1), the unguided model scored FID 1.8 and IS 53.71; $w = 0.1$ gave the best FID, 1.55, with IS 66.11; and $w = 4$ gave IS 260.2 at FID 26.22. At $128 \times 128$ with 256 steps (Table 2), FID fell from 7.27 unguided to 2.43 at $w = 0.3$, below ADM-G’s 2.97, with IS 158.47; at $w = 4$, FID 21.53 and IS 421.03 beat BigGAN-deep at its best-IS truncation (FID 25, IS 253). The text describes FID as monotonically decreasing with $w$ between these extremes, but the tables show it rising for every $w$ above the best value. Figure 5’s legend lists $T = 512$ where the text and Table 2 have $T = 1024$.

Text-to-image diffusion models adopted the method. Imagen’s authors write that their model depends critically on it and sampled MS-COCO with guidance weight 1.35 at $64 \times 64$ (Saharia et al., 2022, Table 1), and Rombach et al. (2022) report that it greatly boosts latent diffusion’s text-to-image samples. The text-to-image generation and Stable Diffusion articles cover these systems.