📘

Alpha-Bar to Beta Inversion

EasyDiffusion Models 📚 Diffusion Models 1

Problem Statement

Given a cumulative product schedule alpha_bar, recover the per-step betas. This is the inverse of the usual forward direction and is how cosine/other schedules defined on alpha_bar get their betas.

Background

With alpha_t = 1 - beta_t and alpha_bar_t = prod_{s<=t} alpha_s, the per-step alpha is the ratio of consecutive cumulative products:

$\alpha_t = \frac{\bar{\alpha}_t}{\bar{\alpha}_{t-1}}, \qquad \beta_t = 1 - \alpha_t$

with alpha_bar_{-1} = 1 for the first step. Betas are typically clipped to avoid values at or above 1; here return them raw.

Your Task

Implement:

def alpha_bar_to_betas(alpha_bar):

Return the list of T betas rounded to 6 decimals.

Input Format

alpha_bar: list of T cumulative products, strictly decreasing in (0, 1].

Output Format

A list of T floats rounded to 6 decimals.

Sample

print(alpha_bar_to_betas([0.9, 0.72, 0.5]))

Output:

[0.1, 0.2, 0.305556]

Example:

Input:

print(alpha_bar_to_betas([0.9, 0.72, 0.5]))

Output:

[0.1, 0.2, 0.305556]

Reasoning:

beta0 = 1 - 0.9/1 = 0.1; beta1 = 1 - 0.72/0.9 = 0.2; beta2 = 1 - 0.5/0.72 = 0.305556.

Constraints:

1 <= T <= 100000; alpha_bar values in (0, 1].
Use alpha_bar_{-1} = 1 for the first step.
beta_t = 1 - alpha_bar_t / alpha_bar_{t-1}; round to 6 decimals.

More from Diffusion Models 1

Classifier-Free Guidance: Uncond/Cond MixingEasy DDPM Posterior Mean and Variance from x0Medium Adaptive CFG Scheduling over the TrajectoryHard Classifier Gradient Guidance StepMedium Negative Prompt as the Unconditional BranchMedium

1. Background Knowledge

In denoising diffusion probabilistic models (DDPMs), the forward process gradually adds Gaussian noise to data over $T$ discrete timesteps. At each step $t$ , a small amount of noise is injected, controlled by a scalar $\beta_t \in (0, 1)$ . The corresponding "signal retention" factor is $\alpha_t = 1 - \beta_t$ , so $\alpha_t$ represents the fraction of the original signal that survives step $t$ .

Rather than working with individual $\alpha_t$ values, it is far more convenient to define the cumulative product (or "alpha-bar") schedule:

\bar{\alpha}_t = \prod_{s=1}^{t} \alpha_s

This quantity tells you the total fraction of original signal remaining after $t$ steps. Many popular noise schedules (e.g., cosine schedule, linear schedule in terms of $\bar{\alpha}$ ) are defined directly on $\bar{\alpha}_t$ because they produce smoother, more interpretable curves. However, the actual forward process implementation needs the per-step $\beta_t$ values to compute the noise scale $\sigma_t = \sqrt{\beta_t}$ .

The key relationship is that $\bar{\alpha}_t$ is a running product, so you can recover each individual $\alpha_t$ by dividing consecutive cumulative products:

\alpha_t = \frac{\bar{\alpha}_t}{\bar{\alpha}_{t-1}}, \quad \text{with } \bar{\alpha}_0 = 1

Then $\beta_t = 1 - \alpha_t$ . This is the inverse of the forward cumulative-product operation and is essential whenever a schedule is specified in terms of $\bar{\alpha}$ rather than $\beta$ .

2. Algorithm Approach

This is a straightforward element-wise ratio problem. You iterate through the alpha_bar array once, and for each index $t$ :

Determine the previous cumulative product: $\bar{\alpha}_{t-1}$ (use $1.0$ for $t = 0$ ).
Compute $\alpha_t = \bar{\alpha}_t / \bar{\alpha}_{t-1}$ .
Compute $\beta_t = 1 - \alpha_t$ .
Round $\beta_t$ to 6 decimal places and append to the result.

No sorting, recursion, or complex data structures are needed—just a single linear pass with a running "previous value" tracker.

👑

Continue the full explanation

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

🔒

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

0/0

Run code to see test results.