扩散模型完全指南：从DDPM到Stable Diffusion，深入理解AI图像生成核心技术

q(x_t | x_{t-1}) = N(x_t; √(1-β_t) * x_{t-1}, β_t * I)

q(x_t | x_0) = N(x_t; √(ᾱ_t) * x_0, (1-ᾱ_t) * I)

def forward_diffusion(x0, t, noise_schedule):
    alpha_bar = noise_schedule.alpha_bar[t]
    noise = torch.randn_like(x0)
    xt = torch.sqrt(alpha_bar) * x0 + torch.sqrt(1 - alpha_bar) * noise
    return xt, noise

p_θ(x_{t-1} | x_t) = N(x_{t-1}; μ_θ(x_t, t), Σ_θ(x_t, t))

μ_θ(x_t, t) = (1/√α_t) * (x_t - (β_t/√(1-ᾱ_t)) * ε_θ(x_t, t))

L = E[||ε - ε_θ(x_t, t)||²]

def training_step(model, x0, noise_schedule):
    t = torch.randint(0, T, (batch_size,))
    noise = torch.randn_like(x0)
    
    xt = forward_diffusion(x0, t, noise_schedule)
    
    predicted_noise = model(xt, t)
    
    loss = F.mse_loss(predicted_noise, noise)
    return loss

@torch.no_grad()
def ddpm_sample(model, shape, noise_schedule, device):
    x = torch.randn(shape, device=device)
    
    for t in reversed(range(noise_schedule.T)):
        t_tensor = torch.full((shape[0],), t, device=device)
        
        predicted_noise = model(x, t_tensor)
        
        alpha = noise_schedule.alpha[t]
        alpha_bar = noise_schedule.alpha_bar[t]
        beta = noise_schedule.beta[t]
        
        mean = (1 / torch.sqrt(alpha)) * (
            x - (beta / torch.sqrt(1 - alpha_bar)) * predicted_noise
        )
        
        if t > 0:
            noise = torch.randn_like(x)
            sigma = torch.sqrt(beta)
            x = mean + sigma * noise
        else:
            x = mean
    
    return x

x_{t-1} = √(ᾱ_{t-1}) * ((x_t - √(1-ᾱ_t) * ε_θ(x_t,t)) / √(ᾱ_t)) + √(1-ᾱ_{t-1}) * ε_θ(x_t,t)

@torch.no_grad()
def ddim_sample(model, shape, noise_schedule, device, steps=50, eta=0.0):
    x = torch.randn(shape, device=device)
    
    timesteps = torch.linspace(noise_schedule.T - 1, 0, steps).long()
    
    for i, t in enumerate(timesteps):
        t_tensor = torch.full((shape[0],), t, device=device)
        
        predicted_noise = model(x, t_tensor)
        
        alpha_bar_t = noise_schedule.alpha_bar[t]
        alpha_bar_prev = noise_schedule.alpha_bar[timesteps[i + 1]] if i < len(timesteps) - 1 else 1.0
        
        x0_pred = (x - torch.sqrt(1 - alpha_bar_t) * predicted_noise) / torch.sqrt(alpha_bar_t)
        
        sigma = eta * torch.sqrt((1 - alpha_bar_prev) / (1 - alpha_bar_t)) * torch.sqrt(1 - alpha_bar_t / alpha_bar_prev)
        
        dir_xt = torch.sqrt(1 - alpha_bar_prev - sigma ** 2) * predicted_noise
        
        noise = torch.randn_like(x) if i < len(timesteps) - 1 else 0
        x = torch.sqrt(alpha_bar_prev) * x0_pred + dir_xt + sigma * noise
    
    return x

class UNetBlock(nn.Module):
    def __init__(self, in_channels, out_channels, time_emb_dim, context_dim):
        super().__init__()
        self.conv1 = nn.Conv2d(in_channels, out_channels, 3, padding=1)
        self.conv2 = nn.Conv2d(out_channels, out_channels, 3, padding=1)
        self.time_mlp = nn.Linear(time_emb_dim, out_channels)
        self.cross_attn = CrossAttention(out_channels, context_dim)
        self.self_attn = SelfAttention(out_channels)
        
    def forward(self, x, t_emb, context):
        h = self.conv1(x)
        h = h + self.time_mlp(t_emb)[:, :, None, None]
        h = self.self_attn(h)
        h = self.cross_attn(h, context)
        h = self.conv2(h)
        return h

def classifier_free_guidance(model, x, t, text_emb, guidance_scale=7.5):
    uncond_emb = model.get_unconditional_embedding()
    
    noise_uncond = model(x, t, uncond_emb)
    noise_cond = model(x, t, text_emb)
    
    noise_pred = noise_uncond + guidance_scale * (noise_cond - noise_uncond)
    return noise_pred

from diffusers import StableDiffusionPipeline

pipe = StableDiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-2-1",
    torch_dtype=torch.float16
).to("cuda")

prompt = "a beautiful sunset over mountains, digital art, highly detailed"
image = pipe(prompt, num_inference_steps=50, guidance_scale=7.5).images[0]
image.save("sunset.png")

from diffusers import StableDiffusionImg2ImgPipeline
from PIL import Image

pipe = StableDiffusionImg2ImgPipeline.from_pretrained(
    "stabilityai/stable-diffusion-2-1",
    torch_dtype=torch.float16
).to("cuda")

init_image = Image.open("input.png").convert("RGB")
prompt = "a fantasy castle, oil painting style"

image = pipe(
    prompt=prompt,
    image=init_image,
    strength=0.75,
    guidance_scale=7.5
).images[0]

from diffusers import StableDiffusionInpaintPipeline

pipe = StableDiffusionInpaintPipeline.from_pretrained(
    "stabilityai/stable-diffusion-2-inpainting",
    torch_dtype=torch.float16
).to("cuda")

image = Image.open("image.png")
mask = Image.open("mask.png")

result = pipe(
    prompt="a cute cat sitting",
    image=image,
    mask_image=mask,
    num_inference_steps=50
).images[0]

from diffusers import StableDiffusionControlNetPipeline, ControlNetModel

controlnet = ControlNetModel.from_pretrained(
    "lllyasviel/control_v11p_sd15_canny",
    torch_dtype=torch.float16
)

pipe = StableDiffusionControlNetPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    controlnet=controlnet,
    torch_dtype=torch.float16
).to("cuda")

canny_image = get_canny_edges(input_image)
result = pipe(prompt, image=canny_image).images[0]

pip install diffusers transformers accelerate torch
pip install xformers  # 可选，用于内存优化

pipe.enable_attention_slicing()

pipe.enable_vae_slicing()

pipe.enable_model_cpu_offload()

pipe.enable_xformers_memory_efficient_attention()

result = pipe(
    prompt="masterpiece, best quality, detailed face, " + user_prompt,
    negative_prompt="low quality, blurry, distorted, deformed",
    num_inference_steps=50,
    guidance_scale=7.5,
    width=768,
    height=768
).images[0]