🤯🤯🤯 还在惊叹AI绘画的神奇？还在花钱求别人帮你生成图片？还在苦苦等待Midjourney的邀请码？别out了！今天，我们就来彻底揭秘AI绘画背后的核心技术——Diffusion模型，让你彻底搞懂它到底是怎么“画”出那些以假乱真的图像的！

🤔️ 焦虑的职场人，你是否也有这些困惑？

*   看到别人用AI生成的精美图片，羡慕不已，自己却无从下手？
*   想学习AI绘画，却被复杂的算法和代码吓退？
*   想提升自己的技能，却找不到通俗易懂的学习资料？

别担心！今天这篇文章，就是为你量身定制的！我们将用最通俗的语言，最形象的比喻，最简单的代码，带你一步步揭开Diffusion模型的神秘面纱！

先奉上源码：

import torch
import torchvision
from tqdm import tqdm
import matplotlib.pyplot as plt
from unet import SimpleUnet
from diffusion import NoiseScheduler


def sample(model, scheduler, num_samples, size, device="cpu"):
    """从噪声采样生成图像的函数
    Args:
        model: UNet模型,用于预测噪声
        scheduler: 噪声调度器,包含采样所需的所有系数
        num_samples: 要生成的样本数量
        size: 生成图像的大小,如(3,32,32)
        device: 运行设备
    Returns:
        生成的图像张量
    """
    model.eval()
    with torch.no_grad():
        # 从标准正态分布采样初始噪声 x_T ~ N(0,I)
        x_t = torch.randn(num_samples, *size).to(device)

        # 逐步去噪,从t=T到t=0
        for t in tqdm(reversed(range(scheduler.num_steps)), desc="Sampling"):
            # 构造时间步batch
            t_batch = torch.tensor([t] * num_samples).to(device)

            # 获取采样需要的系数
            sqrt_recip_alpha_bar = scheduler.get(scheduler.sqrt_recip_alphas_bar, t_batch, x_t.shape)
            sqrt_recipm1_alpha_bar = scheduler.get(scheduler.sqrt_recipm1_alphas_bar, t_batch, x_t.shape)
            posterior_mean_coef1 = scheduler.get(scheduler.posterior_mean_coef1, t_batch, x_t.shape)
            posterior_mean_coef2 = scheduler.get(scheduler.posterior_mean_coef2, t_batch, x_t.shape)

            # 预测噪声 ε_θ(x_t,t)
            predicted_noise = model(x_t, t_batch)

            # 计算x_0的预测值: x_0 = 1/sqrt(α_bar_t) * x_t - sqrt(1/α_bar_t-1) * ε_θ(x_t,t)
            _x_0 = sqrt_recip_alpha_bar * x_t - sqrt_recipm1_alpha_bar * predicted_noise
            # 计算后验分布均值 μ_θ(x_t,t)
            model_mean = posterior_mean_coef1 * _x_0 + posterior_mean_coef2 * x_t
            # 计算后验分布方差的对数值 log(σ_t^2)
            model_log_var = scheduler.get(torch.log(torch.cat([scheduler.posterior_var[1:2], scheduler.betas[1:]])), t_batch, x_t.shape)

            if t > 0:
                # t>0时从后验分布采样: x_t-1 = μ_θ(x_t,t) + σ_t * z, z~N(0,I)
                noise = torch.randn_like(x_t).to(device)
                x_t = model_mean + torch.exp(0.5 * model_log_var) * noise
            else:
                # t=0时直接使用均值作为生成结果
                x_t = model_mean
        # 将最终结果裁剪到[-1,1]范围
        x_0 = torch.clamp(x_t, -1.0, 1.0)
    return x_0


def plot(images):
    fig = plt.figure(figsize=(12, 8))
    plt.axis("off")
    plt.imshow(torchvision.utils.make_grid(images, nrow=5).permute(1, 2, 0))
    plt.tight_layout(pad=1)
    return fig


if __name__ == "__main__":
    image_size = 32
    model = SimpleUnet()
    model.load_state_dict(torch.load(f"simple-unet-ddpm-{image_size}.pth", weights_only=True))
    device = "cuda" if torch.cuda.is_available() else "cpu"
    model.to(device)
    scheduler = NoiseScheduler(device=device)
    
    images = sample(model, scheduler, 10, (3, image_size, image_size), device)
    images = ((images + 1) / 2).detach().cpu()
    fig = plot(images)
    fig.savefig("images-simple-unet-ddpm.png", bbox_inches='tight', pad_inches=0)

 

💣 1. Diffusion模型：从“噪声”中“还原”图像

Diffusion模型，听起来很高大上，其实原理很简单。你可以把它想象成一个“破坏”和“重建”的过程。

*   破坏（加噪）：想象一下，你有一张清晰的照片。你往上面撒盐，撒胡椒粉，撒各种乱七八糟的东西，直到它变成一团模糊的“噪声”。这就是Diffusion模型的“前向过程”，它会逐步给图像添加噪声，直到图像完全变成随机噪声。

*   重建（去噪）：现在，你有一个“魔术师”（也就是我们的AI模型）。他看过无数次“破坏”的过程，已经掌握了其中的规律。他会一点一点地把“噪声”擦掉，逐步还原出原始的图像。这就是Diffusion模型的“逆向过程”，也就是我们最终用来生成图像的过程。
    *   可以把加噪/去噪的过程想象成雕刻。
    *   加噪：相当于把一块完整的石头，每次随机敲掉一小块。重复很多次，直到它变成一堆乱七八糟的碎石。
    *   去噪：相当于反过来，从一堆碎石开始，根据碎石的形状，猜测它原来可能是什么样子，每次敲掉一点，逐渐还原出原来的雕塑。

 

👨‍💻 2. 代码解读：每一步都在做什么？

Talk is cheap, show me the code! 下面我们就来解读一下文章开头给出的代码，看看Diffusion模型具体是怎么工作的。

 

import torch
import torchvision
from tqdm import tqdm
import matplotlib.pyplot as plt
from unet import SimpleUnet
from diffusion import NoiseScheduler

这几行代码主要是导入我们需要用到的库。`torch`是PyTorch深度学习框架，`torchvision`包含了一些常用的图像处理工具，`tqdm`可以显示进度条，`matplotlib`用于绘图，`unet`和`diffusion`是我们自己定义的模型和噪声调度器。

def sample(model, scheduler, num_samples, size, device="cpu"):
    """从噪声采样生成图像的函数
    ...（省略部分代码）...
    """

这个`sample`函数就是Diffusion模型的核心，它负责从噪声中生成图像。

*   `model`: UNet模型，用于预测噪声。你可以把它想象成一个“去噪专家”，他会根据当前的图像和时间步，预测出应该去掉哪些噪声。

*   `scheduler`: 噪声调度器，控制加噪和去噪的过程。它就像一个“时间表”，记录了每一步应该加多少噪声，以及去噪时需要用到的各种系数。

*   `num_samples`: 要生成的图像数量。

*    `size`: 生成图像的大小,如(3,32,32),表示3通道，大小32x32。

*   `device`: 运行设备，可以是CPU或GPU。

model.eval()
    with torch.no_grad():
        # 从标准正态分布采样初始噪声 x_T ~ N(0,I)
        x_t = torch.randn(num_samples, *size).to(device)

这几行代码首先将模型设置为评估模式（`model.eval()`），然后关闭梯度计算（`torch.no_grad()`），因为我们不需要训练模型。接着，从标准正态分布中随机采样一些噪声，作为生成的起点（`x_t`）。

# 逐步去噪,从t=T到t=0
        for t in tqdm(reversed(range(scheduler.num_steps)), desc="Sampling"):
            # 构造时间步batch
            t_batch = torch.tensor([t] * num_samples).to(device)
            ...（省略部分代码）...

这里开始一个循环，从最后一个时间步（`T`）逐步向前，一直到第一个时间步（`0`）。`tqdm`可以显示进度条。`t_batch`表示当前的时间步。

# 获取采样需要的系数
            sqrt_recip_alpha_bar = scheduler.get(scheduler.sqrt_recip_alphas_bar, t_batch, x_t.shape)
            sqrt_recipm1_alpha_bar = scheduler.get(scheduler.sqrt_recipm1_alphas_bar, t_batch, x_t.shape)
            posterior_mean_coef1 = scheduler.get(scheduler.posterior_mean_coef1, t_batch, x_t.shape)
            posterior_mean_coef2 = scheduler.get(scheduler.posterior_mean_coef2, t_batch, x_t.shape)

这几行代码从`scheduler`中获取当前时间步需要用到的系数。这些系数是根据Diffusion模型的数学公式计算出来的，用于后续的去噪计算。别担心，你不需要完全理解这些公式，只需要知道它们的作用是控制去噪的过程。

# 预测噪声 ε_θ(x_t,t)
            predicted_noise = model(x_t, t_batch)

            # 计算x_0的预测值: x_0 = 1/sqrt(α_bar_t) * x_t - sqrt(1/α_bar_t-1) * ε_θ(x_t,t)
            _x_0 = sqrt_recip_alpha_bar * x_t - sqrt_recipm1_alpha_bar * predicted_noise
            # 计算后验分布均值 μ_θ(x_t,t)
            model_mean = posterior_mean_coef1 * _x_0 + posterior_mean_coef2 * x_t
            # 计算后验分布方差的对数值 log(σ_t^2)
            model_log_var = scheduler.get(torch.log(torch.cat([scheduler.posterior_var[1:2], scheduler.betas[1:]])), t_batch, x_t.shape)

这几行代码是去噪的核心。首先，`model(x_t, t_batch)`用UNet模型预测当前图像中的噪声。然后，根据预测的噪声和之前获取的系数，计算出当前时间步的去噪结果（`model_mean`）和方差（`model_log_var`）。

if t > 0:
                # t>0时从后验分布采样: x_t-1 = μ_θ(x_t,t) + σ_t * z, z~N(0,I)
                noise = torch.randn_like(x_t).to(device)
                x_t = model_mean + torch.exp(0.5 * model_log_var) * noise
            else:
                # t=0时直接使用均值作为生成结果
                x_t = model_mean
        # 将最终结果裁剪到[-1,1]范围
        x_0 = torch.clamp(x_t, -1.0, 1.0)
    return x_0

在时间`t>0`的时候根据公式计算出去除了部分噪声的`x_t`,在时间`t=0`的时候，直接输出结果。

最后，将生成的结果裁剪到\[-1, 1]的范围内，保证图像的像素值在合理的范围内。

if __name__ == "__main__":
    image_size = 32
    model = SimpleUnet()
    model.load_state_dict(torch.load(f"simple-unet-ddpm-{image_size}.pth", weights_only=True))
    device = "cuda" if torch.cuda.is_available() else "cpu"
    model.to(device)
    scheduler = NoiseScheduler(device=device)
   
    images = sample(model, scheduler, 10, (3, image_size, image_size), device)
    images = ((images + 1) / 2).detach().cpu()
    fig = plot(images)
    fig.savefig("images-simple-unet-ddpm.png", bbox_inches='tight', pad_inches=0)

这段代码演示了如何使用我们训练好的模型和噪声调度器来生成图像。

🚀 3. 举一反三：你也能创造自己的AI绘画！

掌握了Diffusion模型的核心原理和代码，你就可以开始尝试生成自己的AI绘画了！你可以：

*   调整模型参数，看看不同的参数会对生成结果产生什么影响。
*   尝试不同的噪声调度器，比较它们的生成效果。
*   用自己的数据集训练模型，生成具有特定风格的图像。
*   将Diffusion模型与其他AI技术结合，创造出更惊艳的作品。

 

🔥 总结与互动 🔥

今天，我们一起揭秘了AI绘画的核心技术——Diffusion模型，并用通俗易懂的方式解读了相关代码。希望这篇文章能够帮助你更好地理解AI绘画，激发你的学习兴趣，甚至让你开始动手实践！

互动环节：

*   你对AI绘画还有哪些疑问？
*   你最想用AI生成什么样的图像？
*   你认为AI绘画会对未来的艺术创作产生什么影响？

快来评论区分享你的想法吧！💬💬💬 别忘了点赞👍、收藏⭐、分享🔗给你的朋友，一起探索AI绘画的无限可能！

#AI绘画 #Diffusion模型 #深度学习 #PyTorch #图像生成 #科技前沿 #人人可上手 #爆款文章 #10万+