-
torch.cumprod() w.r.t. diffusion noise schedulingAI\ML\DL/Pytorch 2023. 12. 3. 19:25๋ฐ์ํ
[cumprod: cumulative product ํจ์]
torch.cumprod ํจ์๋ PyTorch ์์ ์ ๊ณตํ๋ ํจ์๋ก, ํ ์์ ๋์ ๊ณฑ์ ์์๋ณ๋ก(element-wise) ๊ณ์ฐํด์ค๋ค.
์ฌ์ฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ๋ค.
import torch tensor = torch.tensor([1, 2, 3, 4]) cumprod_result = torch.cumprod(tensor, dim=0) print(cumprod_result)
tensor([ 1, 2, 6, 24])
์๋ฅผ ๋ค์ด, 'torch.tensor([1,2,3,4])' ํ ์์ ๋ํด torch.cumprod ํจ์๋ฅผ dim=0 (์ฒซ๋ฒ์งธ ์ฐจ์)์ผ๋ก ์ ์ฉํ๋ฉด, ์ด ํจ์๋ ๊ฐ ์์์ ๋์ ๊ณฑ์ ๊ณ์ฐํ์ฌ [1,2,6,24] ๋ฅผ ๋ฐํํ๋ค.
1
1x2=2
1x2x3=6
1x2x3x4=24
[Diffusion model์์ ์ฐ์์]
class Diffusion: def __init__(self, noise_steps=1000, beta_start=1e-4, beta_end=0.02, img_size=256, device="cuda"): self.noise_steps = noise_steps self.beta_start = beta_start self.beta_end = beta_end self.img_size = img_size self.device = device self.beta = self.prepare_noise_schedule().to(device) self.alpha = 1. - self.beta self.alpha_hat = torch.cumprod(self.alpha, dim=0) def prepare_noise_schedule(self): return torch.linspace(self.beta_start, self.beta_end, self.noise_steps) # ๊ฐ timestep ์ ํด๋นํ๋ beta๊ฐ์ ๋ฐํ
๋ํจ์ ๋ชจ๋ธ์์๋ forward ๋ฐ backward ๊ณผ์ ์์ ๊ฐ ๋จ๊ณ๋ณ๋ก ๋ ธ์ด์ฆ ์์ค์ด ๋ค๋ฅธ๋ฐ, ์ ๋จ๊ณ์ ์ด๋ฏธ์ง์์ ์ ์ง์ ์ผ๋ก ๋ ธ์ด์ฆ๋ฅผ ์ถ๊ฐํ๊ฑฐ๋ ์ ๊ฑฐํ๊ธฐ ๋๋ฌธ์ด๋ค. Forward process๋ก ์๋ฅผ ๋ค์๋ฉด ์ด์ ์คํ ์ ์ด๋ฏธ์ง์์ ๋ค์ ์คํ ์ ์ด๋ฏธ์ง๋ก noise๋ฅผ ๊ฐํ ๋ ์ด๋ฏธ์ง์ ๋ ธ์ด์ฆ์๋ ๊ฐ๊ฐ $\sqrt{\alpha_t}$, $\sqrt{1-\alpha_{t}}$ ๋ผ๋ ๊ณ์(coefficient)๊ฐ ๊ณฑํด์ง๋ค.
$$X_t=\sqrt{\alpha_t}X_{t-1}+\sqrt{1-\alpha_{t}}\epsilon_{t-1}, \ \ \alpha _{t}=1-\beta_{t}$$
๊ทธ๋ฐ๋ฐ ์ด๋ t-1์์ t๋ก ๊ฐ์ง ์๊ณ coefficient๋ค์ ๋์ ๊ณฑ์ ์ฌ์ฉํ์ฌ t=0์์ t=T ๋ก ๊ฐ๋ ๋ฐฉ๋ฒ๋ ์๋ค.
์์ forward process ์์ t=0, 1, 2, ... ๋ฅผ ๋์ ํด๋ณด๋ฉด ์๋์ ๊ฐ์ ์๋ค์ ์ป์ ์ ์๋ค.
์ฌ๊ธฐ์ ์ โก์ ์ โ ์ ๋์ ํด๋ณด๋ฉด ์๋์ ๊ฐ์ด ์ธ ์ ์๋ค.
์ฌ๊ธฐ์ $\epsilon_{0}$๊ณผ $\epsilon_{1}$๋ ํ๊ท ์ด 0, ๋ถ์ฐ์ด 1์ธ ๊ฐ์ฐ์์ ๋ถํฌ๋ก๋ถํฐ ํ๋ณธ์ ๊ฐ์(=์ ๋ ฅ ๋ฐ์ดํฐ์ shape) ๋งํผ ๊ฐ์ ๋ฌด์์๋ก ์ถ์ถํ์ฌ ์ป์ ํ ์์ด๋ค. (์ด๋ก ์ ๊ฐ epsilon์ด ํ์ค๊ฐ์ฐ์์๋ถํฌ๋ผ๊ณ ๊ฐ์ ) ์ด๋ ๋ ๋ถํฌ $\epsilon_{0}, \epsilon_{1}$ ๋ฅผ ํฉ์น ์ ์๋ค. ๋ถ์ฐ์ ์ฑ์ง์ ๋ฐ๋ผ epsilon ์์ ๋ถ์ ๊ณ์์ ์ ๊ณฑ์ด ๋ถ์ฐ์ด ๋๋ค.
์ฆ, $(\alpha_2)(1-\alpha _{1})$ ๊ฐ $\epsilon_0$์ ๋ถ์ฐ์ด ๋๊ณ $(1-\alpha_{2})$๊ฐ $\epsilon_1$์ ๋ถ์ฐ์ด ๋๋ค.
๋ ๊ฐ์ ๋ถ์ฐ์ ๊ฐ์ง ๊ฐ์ฐ์์ ๋ถํฌ๋ฅผ ํฉํ๋ฉด ๋ ๋ถํฌ์ ๋ง์ ์ ๋ถ์ฐ์ผ๋ก ๊ฐ์ง๋ ์๋ก์ด ๋ถํฌ๋ฅผ ๋ง๋ค ์์๋ค.
$$\bar{ \alpha _{t}}=\prod_{i=1}^{t}\alpha _{i}=\prod_{i=1}^{t}(1-\beta _{i})$$
๋ฐ๋ผ์ X_t ๋ alpha ์ ๋์ ๊ณฑ๋ค์ ์ ๊ณฑ๊ทผ์ X_0 ์ ๊ณฑํ๊ณ 1-(alpha ๋์ ๊ณฑ) ์ ์ ๊ณฑ๊ทผ์ e_0์ ๊ณฑํ์ฌ ์ป์ ์ ์๋ค.
alpha๋ค์ ๋์ ๊ณฑ์ ํ๊ธฐ ์ํด์ torch.cumprod ํจ์๋ฅผ ์ฌ์ฉํ๋ค.
self.alpha_hat = torch.cumprod(self.alpha, dim=0)
์ด๋ก์จ ๊ฐ ๋จ๊ณ์์์ ๋ ธ์ด์ฆ ์์ค์ ๊ฒฐ์ ํ ์ ์๋ค.
Diffusion์ ์์ธํ ์์ ๊ณผ์ ์ ์๋ ๋งํฌ๋ฅผ ๋ณด๋ฉด ์ ์ ๋ฆฌ๋์ด ์๋ค.
https://lilianweng.github.io/posts/2021-07-11-diffusion-models/
What are Diffusion Models?
[Updated on 2021-09-19: Highly recommend this blog post on score-based generative modeling by Yang Song (author of several key papers in the references)]. [Updated on 2022-08-27: Added classifier-free guidance, GLIDE, unCLIP and Imagen. [Updated on 2022-08
lilianweng.github.io
'AI\ML\DL > Pytorch' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
torch.log_softmax (0) 2024.03.11 ๋ถ์ฐ ๋ฐ ๋ณ๋ ฌ ํ์ต (0) 2023.12.13 torch.cat vs torch.stack (0) 2023.09.29 CNN ๋ชจ๋ธ์ classifier๋จ์์ FC layer์ ์ ๋ ฅ ๋ ธ๋ ๊ฐ์ (0) 2023.08.03