blockdiffusion-api / blockdiffusion /diffusion /gaussian_diffusion.py
wkea's picture
Deploy Space
c388140 verified
Raw History Blame
9.67 kB
from __future__ import annotations
from dataclasses import dataclass
from typing import Any, Dict, Optional, Tuple
import torch
from torch import nn
def _extract(a: torch.Tensor, t: torch.Tensor, x_shape: Tuple[int, ...]) -> torch.Tensor:
"""
从 [T] 的一维张量 a 中按 batch 的 t 抽取,并 reshape 到 x 的维度用于广播。
"""
b = t.shape[0]
out = a.gather(0, t)
return out.reshape(b, *((1,) * (len(x_shape) - 1)))
@dataclass(frozen=True)
class DiffusionConfig:
"""
扩散配置。
"""
timesteps: int = 1000
beta_schedule: str = "cosine" # "linear" 或 "cosine"
class GaussianDiffusion:
"""
标准 Gaussian Diffusion:
- 训练:epsilon-prediction,loss 为 MSE
- 采样:支持 DDPM 与(可选)DDIM
训练循环/保存等不在这里做,以保证训练与采样逻辑解耦。
"""
def __init__(self, betas: torch.Tensor):
if betas.ndim != 1:
raise ValueError("betas 必须是一维张量")
self.device = betas.device
self.betas = betas.float()
self.num_timesteps = int(self.betas.shape[0])
alphas = 1.0 - self.betas
alphas_cumprod = torch.cumprod(alphas, dim=0)
alphas_cumprod_prev = torch.cat([torch.tensor([1.0], device=betas.device), alphas_cumprod[:-1]], dim=0)
self.alphas = alphas
self.alphas_cumprod = alphas_cumprod
self.alphas_cumprod_prev = alphas_cumprod_prev
self.sqrt_alphas_cumprod = torch.sqrt(alphas_cumprod)
self.sqrt_one_minus_alphas_cumprod = torch.sqrt(1.0 - alphas_cumprod)
self.sqrt_recip_alphas_cumprod = torch.sqrt(1.0 / alphas_cumprod)
self.sqrt_recipm1_alphas_cumprod = torch.sqrt(1.0 / alphas_cumprod - 1.0)
# q(x_{t-1}|x_t,x_0) 的 posterior
self.posterior_variance = (
self.betas * (1.0 - alphas_cumprod_prev) / (1.0 - alphas_cumprod)
).clamp(min=1e-20)
self.posterior_log_variance_clipped = torch.log(self.posterior_variance)
self.posterior_mean_coef1 = self.betas * torch.sqrt(alphas_cumprod_prev) / (1.0 - alphas_cumprod)
self.posterior_mean_coef2 = (1.0 - alphas_cumprod_prev) * torch.sqrt(alphas) / (1.0 - alphas_cumprod)
def q_sample(self, x_start: torch.Tensor, t: torch.Tensor, noise: Optional[torch.Tensor] = None) -> torch.Tensor:
"""
前向加噪:q(x_t | x_0)
"""
if noise is None:
noise = torch.randn_like(x_start)
return _extract(self.sqrt_alphas_cumprod, t, x_start.shape) * x_start + _extract(
self.sqrt_one_minus_alphas_cumprod, t, x_start.shape
) * noise
def predict_x0_from_eps(self, x_t: torch.Tensor, t: torch.Tensor, eps: torch.Tensor) -> torch.Tensor:
return _extract(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t - _extract(
self.sqrt_recipm1_alphas_cumprod, t, x_t.shape
) * eps
def q_posterior(self, x_start: torch.Tensor, x_t: torch.Tensor, t: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
"""
返回 q(x_{t-1}|x_t,x_0) 的 posterior mean 与 variance。
"""
posterior_mean = _extract(self.posterior_mean_coef1, t, x_t.shape) * x_start + _extract(
self.posterior_mean_coef2, t, x_t.shape
) * x_t
posterior_variance = _extract(self.posterior_variance, t, x_t.shape)
return posterior_mean, posterior_variance
def training_losses(
self,
model: nn.Module,
x_start: torch.Tensor,
t: torch.Tensor,
model_kwargs: Optional[Dict[str, Any]] = None,
cond_drop_prob: float = 0.0,
snr_gamma: float = 0.0,
) -> Dict[str, torch.Tensor]:
"""
训练损失:MSE(eps_pred, eps)。
可选:SNR 加权(snr_gamma>0),通常能提升采样质量/稳定性。
"""
model_kwargs = dict(model_kwargs or {})
noise = torch.randn_like(x_start)
x_t = self.q_sample(x_start, t, noise=noise)
# Classifier-Free Guidance 的训练方式:以一定概率丢弃条件(mask 全 0 => 等价无条件)
if cond_drop_prob and cond_drop_prob > 0 and ("mask" in model_kwargs):
mask = model_kwargs.get("mask", None)
if mask is not None:
# mask: (B,L);drop: (B,1) 广播到 (B,L)
drop = torch.rand((x_start.shape[0], 1), device=x_start.device) < float(cond_drop_prob)
if mask.dtype == torch.bool:
model_kwargs["mask"] = mask & (~drop)
else:
drop_f = drop.to(dtype=mask.dtype)
model_kwargs["mask"] = mask * (1 - drop_f)
eps_pred = model(x_t, t, **model_kwargs)
mse = (eps_pred - noise) ** 2 # (B,C,H,W)
loss_per = mse.mean(dim=(1, 2, 3)) # (B,)
if snr_gamma and snr_gamma > 0:
# snr = alpha_bar / (1-alpha_bar)
alpha_bar = _extract(self.alphas_cumprod, t, x_start.shape).reshape(x_start.shape[0])
snr = alpha_bar / (1.0 - alpha_bar).clamp(min=1e-12)
# 经典做法:w = min(snr, gamma) / snr
w = torch.minimum(snr, torch.full_like(snr, float(snr_gamma))) / snr.clamp(min=1e-12)
loss_per = loss_per * w
loss = loss_per.mean()
return {"loss": loss}
@torch.no_grad()
def p_mean_variance(
self,
model: nn.Module,
x_t: torch.Tensor,
t: torch.Tensor,
model_kwargs: Optional[Dict[str, Any]] = None,
) -> Dict[str, torch.Tensor]:
"""
DDPM 反向一步:根据 eps_pred 推出 x0_pred,再得到 posterior。
"""
model_kwargs = dict(model_kwargs or {})
eps_pred = model(x_t, t, **model_kwargs)
x0_pred = self.predict_x0_from_eps(x_t, t, eps_pred).clamp(-1.0, 1.0)
model_mean, model_var = self.q_posterior(x0_pred, x_t, t)
return {"mean": model_mean, "variance": model_var, "pred_x0": x0_pred, "pred_eps": eps_pred}
@torch.no_grad()
def p_sample(
self,
model: nn.Module,
x_t: torch.Tensor,
t: torch.Tensor,
model_kwargs: Optional[Dict[str, Any]] = None,
) -> torch.Tensor:
"""
采样一步:x_t -> x_{t-1}(DDPM)。
"""
out = self.p_mean_variance(model, x_t, t, model_kwargs=model_kwargs)
mean, var = out["mean"], out["variance"]
noise = torch.randn_like(x_t)
# t==0 时不再加噪声
nonzero_mask = (t != 0).float().reshape(x_t.shape[0], *((1,) * (x_t.ndim - 1)))
return mean + nonzero_mask * torch.sqrt(var) * noise
@torch.no_grad()
def p_sample_loop(
self,
model: nn.Module,
shape: Tuple[int, int, int, int],
device: torch.device,
model_kwargs: Optional[Dict[str, Any]] = None,
progress: bool = True,
) -> torch.Tensor:
"""
从纯噪声开始逐步采样到 x_0(DDPM)。
"""
img = torch.randn(shape, device=device)
timesteps = range(self.num_timesteps - 1, -1, -1)
if progress:
try:
from tqdm import tqdm # 延迟导入,避免强依赖
except Exception:
tqdm = None
if tqdm is not None:
timesteps = tqdm(timesteps, desc="DDPM Sampling", total=self.num_timesteps)
for i in timesteps:
t = torch.full((shape[0],), i, device=device, dtype=torch.long)
img = self.p_sample(model, img, t, model_kwargs=model_kwargs)
return img
@torch.no_grad()
def ddim_sample_loop(
self,
model: nn.Module,
shape: Tuple[int, int, int, int],
device: torch.device,
steps: int = 50,
eta: float = 0.0,
model_kwargs: Optional[Dict[str, Any]] = None,
progress: bool = True,
) -> torch.Tensor:
"""
DDIM 采样(更少步数、更快)。eta=0 为确定性采样。
"""
if steps <= 1:
raise ValueError("steps 必须 > 1")
img = torch.randn(shape, device=device)
# 选择等间隔的时间序列(从 T-1 到 0)
# 注意:这里用 Python int 列表,避免在 CUDA Tensor 上做 int() 转换导致报错。
times = torch.linspace(self.num_timesteps - 1, 0, steps, dtype=torch.float32).long().tolist()
if progress:
try:
from tqdm import tqdm
except Exception:
tqdm = None
if tqdm is not None:
times = tqdm(list(times), desc="DDIM Sampling", total=steps)
for idx, t_i in enumerate(times):
t = torch.full((shape[0],), int(t_i), device=device, dtype=torch.long)
out = self.p_mean_variance(model, img, t, model_kwargs=model_kwargs)
eps = out["pred_eps"]
x0 = out["pred_x0"]
if idx == len(times) - 1:
img = x0
break
t_next = torch.full((shape[0],), int(times[idx + 1]), device=device, dtype=torch.long)
a_t = _extract(self.alphas_cumprod, t, img.shape)
a_next = _extract(self.alphas_cumprod, t_next, img.shape)
# DDIM 更新公式
sigma = (
eta
* torch.sqrt((1.0 - a_next) / (1.0 - a_t))
* torch.sqrt(1.0 - a_t / a_next)
)
noise = torch.randn_like(img)
dir_xt = torch.sqrt(1.0 - a_next - sigma**2) * eps
img = torch.sqrt(a_next) * x0 + dir_xt + sigma * noise
return img