Classifier-Free Guidance: Uncond/Cond Mixing

easyPROGuidance and Latent DiffusionDiffusion ModelsDiffusion Models 1

Problem Statement

Classifier-free guidance mixes the conditional and unconditional noise predictions to steer generation toward the prompt. Implement the standard linear combination.

Background

Given the unconditional prediction eps_uncond and the conditional prediction eps_cond, the guided noise at guidance scale w is

$\hat{\varepsilon} = \varepsilon_{\text{uncond}} + w\,(\varepsilon_{\text{cond}} - \varepsilon_{\text{uncond}})$

At w = 1 this is just the conditional prediction; larger w extrapolates further in the prompt direction (sharper adherence, less diversity).

Your Task

Implement:

def cfg_combine(eps_uncond, eps_cond, w):

Return the guided noise as a list rounded to 4 decimals.

Input Format

eps_uncond, eps_cond: lists of length D.
w (float): guidance scale.

Output Format

A list of D floats rounded to 4 decimals.

Sample

print(cfg_combine([0.0, 0.0], [1.0, 2.0], 7.5))

Output:

[7.5, 15.0]

Example

Input

print(cfg_combine([0.0, 0.0], [1.0, 2.0], 7.5))

Output

[7.5, 15.0]

Reasoning

Identify the input vectors and guidance scale: the unconditional prediction is $\varepsilon_{\text{uncond}} = [0.0, 0.0]$ , the conditional prediction is $\varepsilon_{\text{cond}} = [1.0, 2.0]$ , and the scale is $w = 7.5$ .
Compute the difference between the conditional and unconditional predictions element-wise to determine the direction of the prompt: $[1.0 - 0.0, 2.0 - 0.0] = [1.0, 2.0]$ .
Scale this difference by the guidance weight $w$ to amplify the conditional signal: $7.5 \times [1.0, 2.0] = [7.5, 15.0]$ .
Add the scaled difference to the unconditional baseline to obtain the guided noise: $[0.0, 0.0] + [7.5, 15.0] = [7.5, 15.0]$ .
Round the resulting values to 4 decimal places, which leaves them unchanged as they are already exact: $[7.5, 15.0]$ .
The final output is [7.5, 15.0]

Constraints

len(eps_uncond) == len(eps_cond).
eps = eps_uncond + w*(eps_cond - eps_uncond).
Round to 4 decimals; avoid -0.0.

Learn this in

Latent Diffusion & Stable DiffusionDiffusion Study Plan

More from Diffusion Models 1

DDPM Posterior Mean and Variance from x0medium Adaptive CFG Scheduling over the Trajectoryhard Classifier Gradient Guidance Stepmedium Negative Prompt as the Unconditional Branchmedium Latent Encode-Decode Round Tripmedium

Concept primerPREVIEW

1. Background Knowledge

Classifier-free guidance (CFG) is a technique used in diffusion models to steer generation toward a text prompt without requiring a separate classifier. During training, the model is trained to predict noise both with and without the conditioning signal (e.g., a text embedding). At inference time, the model is run twice: once with the prompt (yielding $\varepsilon_{\text{cond}}$ ) and once without (yielding $\varepsilon_{\text{uncond}}$ ). The final noise estimate is a linear extrapolation from the unconditional prediction in the direction of the conditional prediction.

The guiding principle is that the difference $\varepsilon_{\text{cond}} - \varepsilon_{\text{uncond}}$ captures the "direction" in latent space that moves the sample toward the prompt. By scaling this difference by a weight $w$ and adding it back to the unconditional baseline, you control how strongly the generation adheres to the prompt. At $w = 1$ , the formula reduces to the pure conditional prediction. For $w > 1$ , the model extrapolates beyond the conditional prediction, producing sharper, more prompt-aligned outputs at the cost of diversity. For $w < 1$ , the result is a blend closer to the unconditional (unprompted) generation.

This linear combination is mathematically equivalent to:

$\hat{\varepsilon} = (1 - w)\,\varepsilon_{\text{uncond}} + w\,\varepsilon_{\text{cond}}$

Both forms are algebraically identical; the first form makes the "extrapolation" interpretation more transparent, while the second form is a standard convex combination (or its extension) of two vectors.

2. Algorithm Approach

The problem is a straightforward element-wise vector operation. You are given two vectors of equal length $D$ and a scalar $w$ . For each index $i$ , compute:

$\hat{\varepsilon}_i = \varepsilon_{\text{uncond},i} + w \cdot (\varepsilon_{\text{cond},i} - \varepsilon_{\text{uncond},i})$

This is a per-element affine transformation. No loops over multiple iterations, no matrix multiplications, no iterative refinement — just a single pass over the vectors. The key insight is recognizing that this is a linear interpolation/extrapolation between two points in $\mathbb{R}^D$ .

3. Step-by-Step Strategy

PRO

Continue the full explanation

You're reading the free preview. Unlock the complete walkthrough, the code editor, test runner and reference solution with Premium.

PRO

Editor locked

The code editor is locked for Pro problems. It is only available for free problems. Please upgrade to gain access to the code editor for all problems.

solution.py

Python 3.13

Test results