擴散模型（Diffusion Model）原理概述
一、核心思想
??擴散模型（Diffusion Model）是一種生成模型，受熱力學中擴散過程的啟發，通過模擬數據從噪聲中逐步去噪的過程來生成樣本。其核心思想是漸進式地添加噪聲（正向過程）和逐步去噪（反向過程）。
??在正向過程中，逐步向數據中添加高斯噪聲，最終將數據轉化為純噪聲；在反向過程中，學習如何從噪聲中逐步去噪，恢復出原始數據分布。
二、前向擴散過程（Forward Diffusion）
??目標：將真實數據逐步“破壞”為隨機噪聲。
??過程：對原始數據（如圖像）進行 T 步微小的高斯噪聲添加，每一步都讓數據更接近純噪聲。
??數學上，第t 步的狀態\(x_t\)由第 t-1 步的狀態\(x_{t-1}\)和噪聲\(\epsilon\)（服從標準正態分布）生成：
\[x_t=\sqrt{\alpha_t}\cdot x_{t-1}+\sqrt{1-\alpha_t}\cdot \epsilon
\]
????其中，\(\alpha_t\)是控制噪聲強度的參數（\(0<\alpha_t<1），隨著 t 增大，x_t\)逐漸接近隨機噪聲。
??結果：經過 T 步后，原始數據完全轉化為與訓練數據無關的高斯噪聲\(x_T\)。
三、逆向擴散過程（Reverse Diffusion）
??目標：從純噪聲中逐步“恢復”出有意義的數據（即生成新樣本）。
??過程：訓練一個神經網絡（通常是 U-Net 結構）學習“去噪”能力 —— 給定第 t 步的帶噪聲數據\(x_t\)，預測它在第 t-1 步的狀態\(x_{t-1}\)（或直接預測添加的噪聲\(\epsilon\)）。
??實際生成時，從隨機噪聲\(x_T\)出發，利用訓練好的網絡反向迭代 T 步，每一步都去除部分噪聲，最終得到接近真實數據分布的生成結果\(x_0\)。
??核心：神經網絡通過學習噪聲的分布規律，實現從噪聲到數據的“逆推”。
四、Python示例
??構建一個基礎的擴散模型，用于生成一維數據。
import matplotlib
matplotlib.use('TkAgg')
import numpy as np
import matplotlib.pyplot as plt
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
plt.rcParams['font.sans-serif']=['SimHei'] # 中文支持
plt.rcParams['axes.unicode_minus']=False # 負號顯示
# 設置隨機種子，確保結果可復現
np.random.seed(42)
torch.manual_seed(42)
# 生成一維數據（示例數據：混合高斯分布）
def generate_data(n_samples=1000):
# 生成兩個高斯分布的數據
cluster1 = np.random.normal(loc=-2.0, scale=0.5, size=(n_samples // 2, 1))
cluster2 = np.random.normal(loc=2.0, scale=0.5, size=(n_samples // 2, 1))
data = np.vstack([cluster1, cluster2])
np.random.shuffle(data)
return data
# 前向過程：逐步添加噪聲
def forward_process(x_0, timesteps, betas):
"""
執行擴散過程的前向步驟，逐步向數據添加噪聲
"""
# 計算alpha和alpha_bar
alphas = 1. - betas
alphas_cumprod = torch.cumprod(alphas, dim=0)
# 隨機選擇一個時間步
t = torch.randint(0, timesteps, (x_0.shape[0],), device=x_0.device)
# 從標準正態分布采樣噪聲
noise = torch.randn_like(x_0)
# 計算x_t
sqrt_alphas_cumprod_t = torch.sqrt(alphas_cumprod[t]).reshape(-1, 1)
sqrt_one_minus_alphas_cumprod_t = torch.sqrt(1 - alphas_cumprod[t]).reshape(-1, 1)
x_t = sqrt_alphas_cumprod_t * x_0 + sqrt_one_minus_alphas_cumprod_t * noise
return x_t, t, noise
# 簡單的神經網絡模型，用于預測噪聲
class SimpleDenoiser(nn.Module):
def __init__(self, input_dim=1, hidden_dim=128):
super(SimpleDenoiser, self).__init__()
self.model = nn.Sequential(
nn.Linear(input_dim + 1, hidden_dim), # +1 for time embedding
nn.SiLU(),
nn.Linear(hidden_dim, hidden_dim),
nn.SiLU(),
nn.Linear(hidden_dim, input_dim)
)
def forward(self, x, t):
# 將時間步t嵌入為模型輸入的一部分
t_emb = t.unsqueeze(-1).float()
x_with_t = torch.cat([x, t_emb], dim=1)
return self.model(x_with_t)
# 訓練函數
def train_diffusion_model(model, dataloader, num_epochs=1000, lr=1e-3):
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = model.to(device)
optimizer = optim.Adam(model.parameters(), lr=lr)
criterion = nn.MSELoss()
# 定義擴散過程的參數
timesteps = 100
betas = torch.linspace(0.0001, 0.02, timesteps, device=device)
for epoch in range(num_epochs):
epoch_loss = 0.0
for batch in dataloader:
x_0 = batch[0].to(device)
# 前向過程：添加噪聲
x_t, t, noise = forward_process(x_0, timesteps, betas)
# 模型預測噪聲
noise_pred = model(x_t, t)
# 計算損失
loss = criterion(noise_pred, noise)
# 反向傳播和優化
optimizer.zero_grad()
loss.backward()
optimizer.step()
epoch_loss += loss.item()
if (epoch + 1) % 100 == 0:
print(f"Epoch {epoch + 1}/{num_epochs}, Loss: {epoch_loss / len(dataloader):.6f}")
return model
# 采樣函數：從噪聲中生成數據
def sample(model, sample_size=1000, timesteps=100):
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = model.to(device)
model.eval()
# 定義擴散過程的參數
betas = torch.linspace(0.0001, 0.02, timesteps, device=device)
alphas = 1. - betas
alphas_cumprod = torch.cumprod(alphas, dim=0)
alphas_cumprod_prev = torch.cat([torch.tensor([1.], device=device), alphas_cumprod[:-1]])
sqrt_recip_alphas = torch.sqrt(1.0 / alphas)
posterior_variance = betas * (1. - alphas_cumprod_prev) / (1. - alphas_cumprod)
# 從標準正態分布開始采樣
x = torch.randn(sample_size, 1, device=device)
with torch.no_grad():
for i in reversed(range(timesteps)):
t = torch.full((sample_size,), i, device=device, dtype=torch.long)
noise_pred = model(x, t)
# 計算均值
sqrt_recip_alphas_t = sqrt_recip_alphas[i]
x = sqrt_recip_alphas_t * (x - betas[i] / torch.sqrt(1 - alphas_cumprod[i]) * noise_pred)
# 添加方差（最后一步不添加）
if i > 0:
noise = torch.randn_like(x)
posterior_variance_t = posterior_variance[i]
x = x + torch.sqrt(posterior_variance_t) * noise
return x.cpu().numpy()
# 主函數
def main():
# 生成數據
data = generate_data(n_samples=1000)
data_tensor = torch.tensor(data, dtype=torch.float32)
# 創建數據加載器
dataset = TensorDataset(data_tensor)
dataloader = DataLoader(dataset, batch_size=32, shuffle=True)
# 初始化模型
model = SimpleDenoiser(input_dim=1)
# 訓練模型
trained_model = train_diffusion_model(model, dataloader, num_epochs=1000)
# 生成樣本
samples = sample(trained_model, sample_size=1000)
# 可視化結果
plt.figure(figsize=(12, 5))
plt.subplot(1, 2, 1)
plt.hist(data, bins=50, density=True, alpha=0.7, label='真實數據')
plt.title('真實數據分布')
plt.xlabel('值')
plt.ylabel('密度')
plt.legend()
plt.subplot(1, 2, 2)
plt.hist(samples, bins=50, density=True, alpha=0.7, label='生成數據', color='orange')
plt.title('擴散模型生成的數據分布')
plt.xlabel('值')
plt.ylabel('密度')
plt.legend()
plt.tight_layout()
plt.show()
if __name__ == "__main__":
main()
??示例展示了擴散模型的主要過程：
????數據生成：使用兩個高斯分布的混合作為示例數據
????前向過程：逐步向數據添加噪聲，最終將數據轉換為噪聲
????模型架構：使用一個簡單的神經網絡來學習預測噪聲
????訓練過程：通過最小化預測噪聲與實際噪聲之間的差異來訓練模型
????采樣過程：從噪聲開始，逐步恢復數據
五、小結
??擴散模型通過“加噪-去噪”的框架，將生成問題轉化為對噪聲分布的逐步修正，其核心在于反向過程的參數化學習和噪聲調度的設計。這一方法在生成任務中展現了強大的潛力，成為當前生成式AI的重要技術之一。
浙公網安備 33010602011771號