Denoising diffusion probabilistic models (DDPM)

DDPM (Ho, Jain and Abbeel, 2020) noises data over T = 1000 Gaussian steps with a linear β schedule and trains a U-Net to predict the added noise with a plain MSE. Sampling runs the learned Gaussian reverse chain from pure noise, 1000 network calls per sample; it reached FID 3.17 on CIFAR-10.

15 min read912 wordsadvanced0 viewsupdated 2026-10-12

Definition

Denoising diffusion probabilistic model (DDPM) is the diffusion model of Ho, Jain and Abbeel, "Denoising Diffusion Probabilistic Models" (NeurIPS 2020). It is a latent-variable model pθ(x0)=∫p(xT)∏t=1Tpθ(xt−1∣xt) dx1:Tp_\theta(x_0)=\int p(x_T)\prod_{t=1}^{T}p_\theta(x_{t-1}\mid x_t)\,dx_{1:T} with a fixed Gaussian forward chain q(xt∣xt−1)q(x_t\mid x_{t-1}). Each reverse step is a Gaussian whose mean is computed from a network εθ(xt,t)\varepsilon_\theta(x_t,t) that predicts the noise in xtx_t, and whose variance is fixed. The network is trained with the unweighted noise-prediction loss LsimpleL_{\text{simple}}. Samples are drawn by ancestral sampling: start at xT∼N(0,I)x_T\sim\mathcal N(0,I) and draw xt−1∼pθ(xt−1∣xt)x_{t-1}\sim p_\theta(x_{t-1}\mid x_t) for t=T,…,1t=T,\dots,1.

Diffusion probabilistic models had been proposed by Sohl-Dickstein et al. in 2015 (see Diffusion models) but produced weak samples. Jonathan Ho, Ajay Jain and Pieter Abbeel made three choices that turned them into a state-of-the-art image generator. They fixed the reverse variances instead of learning them. They parameterised the reverse mean through a noise prediction εθ\varepsilon_\theta, which turns each term of the variational bound into a weighted denoising score-matching loss. And they dropped the weights. On CIFAR-10 this gave an Inception score of 9.46 and FID 3.17, better than the GANs of the time, and LSUN 256×256 samples comparable to ProgressiveGAN. The same paper pointed out the connection to Song and Ermon's score networks and Langevin dynamics.

Forward chain and its posterior

q(xt∣xt−1)=N(αt xt−1, βtI),αt=1−βt,q(xt∣x0)=N(αˉt x0, (1−αˉt)I),αˉt=∏s=1tαsq(x_t\mid x_{t-1})=\mathcal N\big(\sqrt{\alpha_t}\,x_{t-1},\,\beta_tI\big),\quad \alpha_t=1-\beta_t,\qquad q(x_t\mid x_0)=\mathcal N\big(\sqrt{\bar\alpha_t}\,x_0,\,(1-\bar\alpha_t)I\big),\quad \bar\alpha_t=\prod_{s=1}^t\alpha_s
βt\beta_t
linear from β1=10−4\beta_1=10^{-4} to βT=0.02\beta_T=0.02 with T=1000T=1000; small enough that each reverse step is close to Gaussian, large enough that αˉT=4.04×10−5\bar\alpha_T=4.04\times10^{-5}
x0x_0
an image with pixel values scaled linearly to [−1,1][-1,1]
q(xt∣x0)q(x_t\mid x_0)
marginal in closed form: xt=αˉt x0+1−αˉt εx_t=\sqrt{\bar\alpha_t}\,x_0+\sqrt{1-\bar\alpha_t}\,\varepsilon, ε∼N(0,I)\varepsilon\sim\mathcal N(0,I)

The true reverse step q(xt−1∣xt)q(x_{t-1}\mid x_t) is intractable. Conditioned on x0x_0 it is not: by Bayes' rule and the Gaussian forward kernels it is a Gaussian with known mean and variance.

q(xt−1∣xt,x0)=N(μ~t(xt,x0), β~tI),μ~t=αˉt−1 βt1−αˉt x0+αt (1−αˉt−1)1−αˉt xt,β~t=1−αˉt−11−αˉt βtq(x_{t-1}\mid x_t,x_0)=\mathcal N\big(\tilde\mu_t(x_t,x_0),\,\tilde\beta_tI\big),\qquad \tilde\mu_t=\frac{\sqrt{\bar\alpha_{t-1}}\,\beta_t}{1-\bar\alpha_t}\,x_0+\frac{\sqrt{\alpha_t}\,(1-\bar\alpha_{t-1})}{1-\bar\alpha_t}\,x_t,\qquad \tilde\beta_t=\frac{1-\bar\alpha_{t-1}}{1-\bar\alpha_t}\,\beta_t
μ~t\tilde\mu_t
a weighted average of the clean sample and the current noisy one; for large tt almost all weight is on xtx_t (0.9941 against 0.0031 at t=500t=500)
β~t\tilde\beta_t
posterior variance; slightly below βt\beta_t, and much smaller only for the first few steps (β~1=0\tilde\beta_1=0)

The ε-parameterisation and L_simple

The model is pθ(xt−1∣xt)=N(μθ(xt,t),σt2I)p_\theta(x_{t-1}\mid x_t)=\mathcal N(\mu_\theta(x_t,t),\sigma_t^2I). The variational bound splits into a KL term per step, Lt−1=DKL(q(xt−1∣xt,x0) ∥ pθ(xt−1∣xt))L_{t-1}=D_{\mathrm{KL}}\big(q(x_{t-1}\mid x_t,x_0)\,\|\,p_\theta(x_{t-1}\mid x_t)\big). Between two Gaussians with the same fixed variance, this KL is a squared distance between the means. Instead of predicting μ~t\tilde\mu_t directly, write x0x_0 in terms of xtx_t and the noise, and let the network predict the noise:

μθ(xt,t)=1αt(xt−βt1−αˉt εθ(xt,t)),Lt−1=E[βt22σt2 αt(1−αˉt)∥ε−εθ(xt,t)∥2]+C\mu_\theta(x_t,t)=\frac{1}{\sqrt{\alpha_t}}\Big(x_t-\frac{\beta_t}{\sqrt{1-\bar\alpha_t}}\,\varepsilon_\theta(x_t,t)\Big),\qquad L_{t-1}=\mathbb E\Big[\frac{\beta_t^2}{2\sigma_t^2\,\alpha_t(1-\bar\alpha_t)}\big\|\varepsilon-\varepsilon_\theta(x_t,t)\big\|^2\Big]+C
μθ\mu_\theta
exactly μ~t(xt,x^0)\tilde\mu_t(x_t,\hat x_0) with x^0=(xt−1−αˉt εθ)/αˉt\hat x_0=(x_t-\sqrt{1-\bar\alpha_t}\,\varepsilon_\theta)/\sqrt{\bar\alpha_t} substituted for the unknown x0x_0
σt2\sigma_t^2
fixed reverse variance, βt\beta_t or β~t\tilde\beta_t; the paper found both gave similar sample quality
CC
a constant independent of θ\theta
Lsimple(θ)=Et∼U{1,…,T}, x0, ε∼N(0,I)[∥ε−εθ(αˉt x0+1−αˉt ε, t)∥2]L_{\text{simple}}(\theta)=\mathbb E_{t\sim\mathcal U\{1,\dots,T\},\ x_0,\ \varepsilon\sim\mathcal N(0,I)}\Big[\big\|\varepsilon-\varepsilon_\theta\big(\sqrt{\bar\alpha_t}\,x_0+\sqrt{1-\bar\alpha_t}\,\varepsilon,\ t\big)\big\|^2\Big]
LsimpleL_{\text{simple}}
the bound with the per-step weight set to 1; this down-weights the small-tt terms, where denoising is easy, relative to the true bound
t=1t=1
the discrete decoder term L0L_0 of the bound is approximated by the same MSE at t=1t=1

Why the weights matter, and how ε-, x0x_0- and v-prediction relate, is covered in Diffusion noise-prediction loss. The paper also tried predicting μ~t\tilde\mu_t directly. That works only with the true bound and gives worse samples. ε-prediction resembles Langevin dynamics, because εθ\varepsilon_\theta is a scaled score: εθ(xt,t)≈−1−αˉt ∇xtlog⁡q(xt)\varepsilon_\theta(x_t,t)\approx-\sqrt{1-\bar\alpha_t}\,\nabla_{x_t}\log q(x_t) (see Score-based generative models).

The paper's two algorithms

  1. 1Training (Algorithm 1). Repeat: take x0x_0 from the data, t∼U{1,…,T}t\sim\mathcal U\{1,\dots,T\}, ε∼N(0,I)\varepsilon\sim\mathcal N(0,I); take a gradient step on ∥ε−εθ(αˉtx0+1−αˉtε,t)∥2\|\varepsilon-\varepsilon_\theta(\sqrt{\bar\alpha_t}x_0+\sqrt{1-\bar\alpha_t}\varepsilon,t)\|^2.
  2. 2Sampling (Algorithm 2). Draw xT∼N(0,I)x_T\sim\mathcal N(0,I). For t=T,…,1t=T,\dots,1: z∼N(0,I)z\sim\mathcal N(0,I) if t>1t>1, else z=0z=0, and xt−1=1αt(xt−1−αt1−αˉtεθ(xt,t))+σtzx_{t-1}=\frac{1}{\sqrt{\alpha_t}}\big(x_t-\frac{1-\alpha_t}{\sqrt{1-\bar\alpha_t}}\varepsilon_\theta(x_t,t)\big)+\sigma_tz. Return x0x_0.
  3. 3Sampling needs T=1000T=1000 sequential network evaluations per batch. Denoising diffusion implicit models (DDIM) reuses the same trained εθ\varepsilon_\theta with far fewer steps.

Architecture and setup

Setup in the paper (Ho et al. 2020)

Schedule
T=1000T=1000, βt\beta_t linear from 10−410^{-4} to 0.020.02; σt2=βt\sigma_t^2=\beta_t or β~t\tilde\beta_t (similar results)
Network
U-Net based on an unmasked PixelCNN++: Wide ResNet blocks, group normalisation, self-attention at the 16×16 resolution, and the Transformer's sinusoidal embedding of tt added in every residual block; parameters shared across tt
Size
35.7M parameters for CIFAR-10, 114M for LSUN and CelebA-HQ (256×256), about 256M for a larger LSUN Bedroom model
Optimisation
Adam, learning rate 2×10−42\times10^{-4} (2×10−52\times10^{-5} at 256×256), EMA of weights with decay 0.9999; dropout 0.1 and random horizontal flips on CIFAR-10; 800K steps at batch 128 for CIFAR-10 on a TPU v3-8
Loss
LsimpleL_{\text{simple}}; the true variational bound gives better likelihoods but worse samples
parameterisation and objectiveISFIDNLL (bits/dim)
predict μ̃, true bound L, fixed isotropic Σ8.0613.22
predict ε, true bound L, fixed isotropic Σ7.6713.51≤ 3.70
predict ε, L_simple9.463.17≤ 3.75
CIFAR-10 unconditional results (Ho et al. 2020, Tables 1 and 2); NLL is an upper bound on the test set

On LSUN 256×256 the paper reports FID 7.89 for Church and 6.36 for Bedroom (4.90 with the larger model). The likelihoods are worse than those of autoregressive models. The authors explain this through a rate–distortion analysis: most of the lossless codelength describes imperceptible image details, which LsimpleL_{\text{simple}} deliberately down-weights. Running the chain as progressive decoding shows large-scale features appearing first and fine details last.

The cosine schedule (Nichol & Dhariwal, 2021)

αˉt=f(t)f(0),f(t)=cos⁡2 ⁣(t/T+s1+s⋅π2),s=0.008,βt=min⁡ ⁣(1−αˉtαˉt−1, 0.999)\bar\alpha_t=\frac{f(t)}{f(0)},\qquad f(t)=\cos^2\!\Big(\frac{t/T+s}{1+s}\cdot\frac{\pi}{2}\Big),\qquad s=0.008,\qquad \beta_t=\min\!\Big(1-\frac{\bar\alpha_t}{\bar\alpha_{t-1}},\ 0.999\Big)
ff
makes αˉt\bar\alpha_t fall slowly at both ends and roughly linearly in the middle
ss
small offset so that βt\beta_t is not too small near t=0t=0
0.9990.999
clip that prevents a singularity at t=Tt=T, where αˉT→0\bar\alpha_T\to0

In "Improved Denoising Diffusion Probabilistic Models" (ICML 2021), Alex Nichol and Prafulla Dhariwal noticed that with the linear schedule the last part of the forward chain is almost pure noise and contributes little. The SNR αˉt/(1−αˉt)\bar\alpha_t/(1-\bar\alpha_t) drops below 1 at t=260t=260 for the linear schedule and at t=497t=497 for the cosine one. They also learned the reverse variance as an interpolation Σθ=exp⁡(vlog⁡βt+(1−v)log⁡β~t)\Sigma_\theta=\exp(v\log\beta_t+(1-v)\log\tilde\beta_t), trained with a hybrid loss Lsimple+λLvlbL_{\text{simple}}+\lambda L_{\text{vlb}} with λ=0.001\lambda=0.001. That improved log-likelihoods and allowed sampling with far fewer steps.

x_(t−1) = (x_t − β_t/√(1−ᾱ_t) · ε*(x_t, t)) / √α_t + σ_t z-2-101210007505002500x̂₀800 samples vs q(x₀)shade q(x_t) · 24 paths (rose: end below 0) · ● x_t at cursor · ticks x̂₀ = E[x₀|x_t]β_t 0.0100ᾱ_t 0.0786SNR_t 0.0853σ_t 0.10021/√α_t 1.0051β_t/√(1−ᾱ_t) 0.0105mean coef on x₀ 0.0031mean coef on x_t 0.9941step t = 500sample mean 0.302 (true 0.330)sample std 0.888 (true 0.889)share x₀ > 0 69.1% (true 70%)q(x_(t−1)|x_t, x₀) has mean (x₀ coef)·x₀ + (x_t coef)·x_t; at x₀ = x̂₀ that is this updateε* = exact E[ε | x_t] for this mixture (a perfect ε_θ) · ᾱ_T = 4.04e-5 · 1000 network calls per sample
schedule
variance
fig.One-dimensional data q(x₀) = 0.3·N(−1, 0.12²) + 0.7·N(0.9, 0.2²) (mean 0.330, std 0.889). Its noised marginals are mixtures too, so the optimal ε*(x_t, t) = E[ε | x_t] is computed exactly and stands in for a perfectly trained network. The shading is q(x_t), normalised per column. 800 chains run Algorithm 2 for all 1000 steps, and 24 of them are drawn (rose if they end below 0). With the linear schedule and σ² = β the 800 samples have mean 0.302, std 0.888 and 69.1% above zero (true 70%). σ² = β̃ gives 0.303, 0.885 and 69.3%. The cosine schedule gives 0.321, 0.886 and 70.0%. Move the cursor to see the posterior-mean predictions x̂₀ of the drawn chains. At t = 750 (linear) they all lie between 0.25 and 0.41, close to the data mean: the noise carries almost no information about x₀ yet. At t = 500 they span −0.22 to 0.66, and by t = 250 the chains have committed to a mode (−1.00 to 0.95). With the cosine schedule they already span −0.21 to 0.74 at t = 750. The readouts show that the update coefficients barely change with t: 1/√α_t goes from 1.000 to 1.010, and the posterior mean puts 0.9941 of its weight on x_t at t = 500.

Worked example: one reverse step

tβ_tᾱ_tβ̃_t1/√α_tβ_t/√(1−ᾱ_t)cx₀cx_t
21.199 × 10⁻⁴0.99985.45 × 10⁻⁵1.00010.008090.54530.4547
102.793 × 10⁻⁴0.99812.382 × 10⁻⁴1.00010.006420.14730.8527
1000.0020720.89700.0020351.00100.006460.019080.9809
5000.010040.078590.010031.00510.010460.0030700.9941
10000.020004.04 × 10⁻⁵0.020001.01020.020001.28 × 10⁻⁴0.9899
Linear schedule quantities at selected t (computed in Node); cx₀ and cx_t are the posterior-mean coefficients of x₀ and x_t

x_t = 0.5 at t = 100, on the figure's mixture, with the exact ε*

  1. 1αˉ100=0.89702\bar\alpha_{100}=0.89702, so αˉt=0.94711\sqrt{\bar\alpha_t}=0.94711 and 1−αˉt=0.32091\sqrt{1-\bar\alpha_t}=0.32091. The exact noise prediction is ε∗=−0.81396\varepsilon^*=-0.81396.
  2. 2Denoised estimate: x^0=(0.5+0.32091⋅0.81396)/0.94711=0.80372\hat x_0=(0.5+0.32091\cdot0.81396)/0.94711=0.80372, pulled toward the larger mode at 0.90.9.
  3. 3Posterior mean at x^0\hat x_0: μ~=0.019076⋅0.80372+0.98090⋅0.5=0.505780\tilde\mu=0.019076\cdot0.80372+0.98090\cdot0.5=0.505780.
  4. 4Algorithm 2's mean: 1αt(xt−βt1−αˉtε∗)=1.00104⋅(0.5+0.0064569⋅0.81396)=0.505780\frac{1}{\sqrt{\alpha_t}}(x_t-\frac{\beta_t}{\sqrt{1-\bar\alpha_t}}\varepsilon^*)=1.00104\cdot(0.5+0.0064569\cdot0.81396)=0.505780. The two agree, as the derivation says.
  5. 5Add noise: σt=βt=0.04552\sigma_t=\sqrt{\beta_t}=0.04552 or β~t=0.04511\sqrt{\tilde\beta_t}=0.04511, so x99=0.50578+0.0455 zx_{99}=0.50578+0.0455\,z. The step moves the mean by only 0.0058; the noise term is eight times larger. That is why 1000 steps are needed.
python
1import math, torch, torch.nn as nn, torch.nn.functional as F
2
3class DDPM:
4 def __init__(self, T=1000, schedule="linear"):
5 self.T = T
6 if schedule == "linear":
7 beta = torch.linspace(1e-4, 0.02, T, dtype=torch.float64)
8 else: # cosine (Nichol & Dhariwal 2021), s = 0.008
9 s = 0.008
10 f = lambda t: torch.cos((t / T + s) / (1 + s) * math.pi / 2) ** 2
11 t = torch.arange(T + 1, dtype=torch.float64)
12 beta = (1 - f(t[1:]) / f(t[:-1])).clamp(max=0.999)
13 self.beta = beta.float() # index i ↔ step t = i + 1
14 self.alpha = 1 - self.beta
15 self.abar = torch.cumprod(beta.new_ones(T) - beta, 0).float()
16 self.abar_prev = F.pad(self.abar[:-1], (1, 0), value=1.0)
17 self.beta_tilde = self.beta * (1 - self.abar_prev) / (1 - self.abar)
18
19 def q_sample(self, x0, t, eps): # x_t = √ᾱ_t x0 + √(1-ᾱ_t) ε
20 a = self.abar[t - 1].view(-1, 1, 1, 1)
21 return a.sqrt() * x0 + (1 - a).sqrt() * eps
22
23 def loss(self, model, x0): # L_simple
24 t = torch.randint(1, self.T + 1, (x0.size(0),))
25 eps = torch.randn_like(x0)
26 return F.mse_loss(model(self.q_sample(x0, t, eps), t), eps)
27
28 def posterior_mean(self, x0, xt, t): # μ̃_t(x_t, x0) of q(x_{t-1} | x_t, x0)
29 i = t - 1
30 c0 = self.abar_prev[i].sqrt() * self.beta[i] / (1 - self.abar[i])
31 ct = self.alpha[i].sqrt() * (1 - self.abar_prev[i]) / (1 - self.abar[i])
32 return c0 * x0 + ct * xt
33
34 @torch.no_grad()
35 def sample(self, model, shape, var="beta"): # Algorithm 2 (ancestral sampling)
36 x = torch.randn(shape)
37 for t in range(self.T, 0, -1):
38 i = t - 1
39 eps = model(x, torch.full((shape[0],), t))
40 mean = (x - self.beta[i] / (1 - self.abar[i]).sqrt() * eps) / self.alpha[i].sqrt()
41 sigma = (self.beta[i] if var == "beta" else self.beta_tilde[i]).sqrt()
42 x = mean + sigma * torch.randn_like(x) if t > 1 else mean
43 return x
44
45def timestep_embedding(t, dim): # sinusoidal, as in the Transformer
46 half = dim // 2
47 freqs = torch.exp(-math.log(10000) * torch.arange(half) / half)
48 a = t.float()[:, None] * freqs[None]
49 return torch.cat([a.sin(), a.cos()], 1)
50
51class TinyDenoiser(nn.Module): # stand-in for the U-Net: conv blocks + t embedding
52 def __init__(self, ch=3, h=32):
53 super().__init__()
54 self.temb = nn.Sequential(nn.Linear(h, h), nn.SiLU(), nn.Linear(h, h))
55 self.inp = nn.Conv2d(ch, h, 3, padding=1)
56 self.mid = nn.Sequential(nn.GroupNorm(8, h), nn.SiLU(), nn.Conv2d(h, h, 3, padding=1))
57 self.out = nn.Conv2d(h, ch, 3, padding=1)
58 self.h = h
59 def forward(self, x, t):
60 e = self.temb(timestep_embedding(t, self.h))[:, :, None, None]
61 return self.out(self.mid(self.inp(x) + e))
62
63d = DDPM()
64model = TinyDenoiser()
65x0 = torch.rand(8, 3, 32, 32) * 2 - 1 # images scaled to [-1, 1]
66loss = d.loss(model, x0); loss.backward()
67print(loss.shape, f"{d.abar[-1].item():.2e}") # torch.Size([]) 4.04e-05
68
69# Algorithm 2's mean is the posterior mean evaluated at x̂0 = (x_t - √(1-ᾱ_t) ε)/√ᾱ_t
70t = torch.tensor([100]); xt = torch.randn(1, 3, 32, 32); eps = torch.randn_like(xt)
71a = d.abar[t - 1]
72x0_hat = (xt - (1 - a).sqrt() * eps) / a.sqrt()
73alg2 = (xt - d.beta[t - 1] / (1 - a).sqrt() * eps) / d.alpha[t - 1].sqrt()
74print(torch.allclose(alg2, d.posterior_mean(x0_hat, xt, t), atol=1e-5)) # True
75
76x = d.sample(model.eval(), (2, 3, 32, 32)) # 1000 network calls
77print(x.shape) # torch.Size([2, 3, 32, 32])
78c = DDPM(schedule="cosine")
79print(f"{c.abar[499].item():.4f} {d.abar[499].item():.4f}") # 0.4938 0.0786 (ᾱ_500: cosine keeps more signal)
DDPM in PyTorch: schedules, q_sample, L_simple, the posterior mean, and Algorithm 2 (a tiny conv net stands in for the U-Net)

Use when

  • +Simple, stable training: one MSE, no adversary, no learned variances needed
  • +High sample quality and full mode coverage (CIFAR-10 FID 3.17 in 2020)
  • +Principled: a variational bound gives log-likelihood estimates and connects to score matching
  • +The trained ε_θ is reused by faster samplers (DDIM, ODE solvers) without retraining

Avoid when

  • −Sampling is slow: 1000 sequential network evaluations per sample
  • −Likelihoods are worse than those of autoregressive models when trained with L_simple
  • −Fixed variances and the linear schedule are suboptimal for few-step sampling
  • −Pixel-space U-Nets are expensive at high resolution

Check yourself

In DDPM, the network output ε_θ(x_t, t) enters the reverse step through which mean?

Check yourself

Ho et al. trained with L_simple rather than the true variational bound. What did they observe?

Remember

  • ✓DDPM: q(xt∣x0)=N(αˉtx0,(1−αˉt)I)q(x_t\mid x_0)=\mathcal N(\sqrt{\bar\alpha_t}x_0,(1-\bar\alpha_t)I), T=1000T=1000, linear β\beta from 10−410^{-4} to 0.020.02; train with Lsimple=E∥ε−εθ(xt,t)∥2L_{\text{simple}}=\mathbb E\|\varepsilon-\varepsilon_\theta(x_t,t)\|^2.
  • ✓Sampling: xt−1=1αt(xt−βt1−αˉtεθ(xt,t))+σtzx_{t-1}=\frac{1}{\sqrt{\alpha_t}}\big(x_t-\frac{\beta_t}{\sqrt{1-\bar\alpha_t}}\varepsilon_\theta(x_t,t)\big)+\sigma_tz with σt2=βt\sigma_t^2=\beta_t or β~t\tilde\beta_t; 1000 network calls.
  • ✓The reverse mean equals the posterior mean μ~t(xt,x^0)\tilde\mu_t(x_t,\hat x_0) at the network's denoised estimate x^0\hat x_0.
  • ✓CIFAR-10: FID 3.17 and IS 9.46 with L_simple, against FID 13.51 with the true bound; U-Net with 35.7M parameters.
  • ✓Cosine schedule (Nichol & Dhariwal 2021): αˉt=f(t)/f(0)\bar\alpha_t=f(t)/f(0), f=cos⁡2(t/T+s1+sπ2)f=\cos^2(\frac{t/T+s}{1+s}\frac\pi2), s=0.008s=0.008, keeps SNR ≥ 1 for about half the chain.
← back to Deep Learning roadmap