扩散模型变体：从基础到高级实现

扩散模型变体：从基础到高级实现

【免费下载链接】denoising-diffusion-pytorch Implementation of Denoising Diffusion Probabilistic Model in Pytorch 项目地址: https://gitcode.com/gh_mirrors/de/denoising-diffusion-pytorch

本文系统介绍了扩散模型的重要变体，从连续时间高斯扩散模型到学习型高斯扩散与加权目标方法，再到阐明扩散(Elucidated Diffusion)和V参数连续时间扩散模型。这些变体通过数学创新和架构优化，显著提升了扩散模型的训练稳定性、采样效率和生成质量。文章详细解析了每种变体的核心原理、数学基础、实现架构和应用场景，为读者提供了从理论到实践的全面指导。

连续时间高斯扩散模型

连续时间高斯扩散模型是扩散模型领域的一个重要变体，它将传统的离散时间步扩散过程扩展到连续时间域。这种扩展不仅提供了更灵活的时间调度机制，还能更好地处理不同噪声水平下的生成过程。

核心概念与数学基础

连续时间扩散模型的核心思想是将离散的时间步替换为连续的时间变量 $t \in [0, 1]$，其中 $t=0$ 对应纯净数据，$t=1$ 对应完全噪声。信号噪声比（SNR）的对数形式被定义为时间 $t$ 的函数：

def log_snr(t):
    """信号噪声比的对数形式"""
    return -log(expm1(1e-4 + 10 * (t ** 2)))

该实现支持多种噪声调度策略：

调度策略	数学表达式	特点
线性调度	$\log(\text{SNR}) = -\log(e^{1e-4 + 10t^2} - 1)$	近似原始线性调度
余弦调度	$\log(\text{SNR}) = -\log(\cos^2(\frac{\pi}{2}\frac{t+s}{1+s}) - 1)$	平滑过渡，避免边界效应
学习调度	神经网络参数化	自适应调整，最优性能

模型架构与实现

连续时间高斯扩散模型的核心类是 ContinuousTimeGaussianDiffusion，它继承自 nn.Module，主要包含以下组件：

class ContinuousTimeGaussianDiffusion(nn.Module):
    def __init__(
        self,
        model,                    # 基础UNet模型
        image_size,               # 图像尺寸
        channels=3,               # 通道数
        noise_schedule='linear',  # 噪声调度策略
        num_sample_steps=500,     # 采样步数
        clip_sample_denoised=True # 是否裁剪去噪样本
    ):

前向扩散过程

在前向扩散过程中，给定初始数据 $x_0$ 和时间 $t$，加噪后的数据计算为：

def q_sample(self, x_start, times, noise=None):
    noise = default(noise, lambda: torch.randn_like(x_start))
    log_snr = self.log_snr(times)
    
    log_snr_padded = right_pad_dims_to(x_start, log_snr)
    alpha, sigma = sqrt(log_snr_padded.sigmoid()), sqrt((-log_snr_padded).sigmoid())
    x_noised = x_start * alpha + noise * sigma
    
    return x_noised, log_snr

其中 $\alpha = \sqrt{\sigma(\log \text{SNR})}$ 和 $\sigma = \sqrt{\sigma(-\log \text{SNR})}$ 分别控制信号和噪声的权重。

反向生成过程

反向生成过程通过迭代采样实现：

具体的采样算法实现：

@torch.no_grad()
def p_sample(self, x, time, time_next):
    batch, *_, device = *x.shape, x.device
    
    model_mean, model_variance = self.p_mean_variance(x=x, time=time, time_next=time_next)
    
    if time_next == 0:
        return model_mean
    
    noise = torch.randn_like(x)
    return model_mean + sqrt(model_variance) * noise

训练策略与损失函数

连续时间扩散模型的训练采用噪声预测目标：

def p_losses(self, x_start, times, noise=None):
    noise = default(noise, lambda: torch.randn_like(x_start))
    
    x, log_snr = self.q_sample(x_start=x_start, times=times, noise=noise)
    model_out = self.model(x, log_snr)
    
    losses = F.mse_loss(model_out, noise, reduction='none')
    losses = reduce(losses, 'b ... -> b', 'mean')
    
    # 最小SNR损失权重
    if self.min_snr_loss_weight:
        snr = log_snr.exp()
        loss_weight = snr.clamp(min=self.min_snr_gamma) / snr
        losses = losses * loss_weight
    
    return losses.mean()

该实现还支持最小SNR损失权重技术，通过调整不同噪声水平下的损失权重来改善训练稳定性。

学习型噪声调度

一个重要的创新是学习型噪声调度机制：

class learned_noise_schedule(nn.Module):
    def __init__(
        self,
        log_snr_max,        # 最大log SNR
        log_snr_min,        # 最小log SNR
        hidden_dim=1024,    # 隐藏层维度
        frac_gradient=1.    # 梯度回传比例
    ):

学习型调度器通过神经网络参数化噪声调度过程，能够自适应地找到最优的噪声调度策略。

性能优化技术

连续时间扩散模型采用了多种性能优化技术：

1. 梯度分数控制：通过 frac_gradient 参数控制梯度回传比例，稳定训练过程
2. 动态阈值裁剪：在采样过程中对去噪后的样本进行裁剪，保持数值稳定性
3. 混合精度训练：支持自动混合精度训练，减少内存占用并加速训练

应用场景与优势

连续时间高斯扩散模型在以下场景中表现出色：

• 高质量图像生成：连续时间调度提供更精细的生成控制
• 快速采样：通过调整采样步数平衡质量与速度
• 自适应调度：学习型调度器能够适应不同数据集特性
• 理论研究：为扩散模型的数学分析提供连续时间框架

该模型的实现充分考虑了实际应用需求，提供了灵活的配置选项和高效的训练推理流程，是扩散模型研究与应用的重要工具。

学习型高斯扩散与加权目标

在扩散模型的发展历程中，学习型高斯扩散（Learned Gaussian Diffusion）和加权目标（Weighted Objective）代表了两种重要的技术演进方向。这些方法通过引入更复杂的损失函数设计和模型输出策略，显著提升了扩散模型的训练稳定性和生成质量。

学习型高斯扩散的核心原理

学习型高斯扩散是对传统扩散模型的重要扩展，它允许模型学习方差参数而不仅仅是均值。在标准扩散过程中，方差通常是预定义的固定值，但学习型方法让模型能够动态预测每个时间步的最优方差。

技术架构设计

学习型高斯扩散通过修改UNet架构的输出维度来实现，要求模型输出通道数为输入通道数的两倍：

class LearnedGaussianDiffusion(GaussianDiffusion):
    def __init__(
        self,
        model,
        vb_loss_weight = 0.001,  # 论文中lambda为0.001
        *args,
        **kwargs
    ):
        super().__init__(model, *args, **kwargs)
        assert model.out_dim == (model.channels * 2), 'UNet输出维度必须是通道数的两倍'
        assert not model.self_condition, '暂不支持自条件'
        
        self.vb_loss_weight = vb_loss_weight

这种设计使得模型能够同时预测噪声和方差插值分数，实现了对后验分布更精确的建模。

方差学习机制

学习型扩散采用方差插值策略，将模型预测的方差表示为最大和最小方差的加权组合：

def p_mean_variance(self, *, x, t, clip_denoised, model_output = None, **kwargs):
    model_output = default(model_output, lambda: self.model(x, t))
    pred_noise, var_interp_frac_unnormalized = model_output.chunk(2, dim=1)
    
    min_log = extract(self.posterior_log_variance_clipped, t, x.shape)
    max_log = extract(torch.log(self.betas), t, x.shape)
    var_interp_frac = unnormalize_to_zero_to_one(var_interp_frac_unnormalized)
    
    model_log_variance = var_interp_frac * max_log + (1 - var_interp_frac) * min_log
    model_variance = model_log_variance.exp()

变分下界损失函数

学习型扩散的核心创新在于引入了变分下界（VLB）损失，该损失通过KL散度来衡量真实后验分布与模型预测分布之间的差异：

def p_losses(self, x_start, t, noise = None, clip_denoised = False):
    # 计算真实后验分布参数
    true_mean, _, true_log_variance_clipped = self.q_posterior(
        x_start = x_start, x_t = x_t, t = t
    )
    
    # 计算模型预测分布参数
    model_mean, _, model_log_variance, _ = self.p_mean_variance(
        x = x_t, t = t, clip_denoised = clip_denoised, 
        model_output = model_output
    )
    
    # 计算KL散度损失
    kl = normal_kl(true_mean, true_log_variance_clipped, 
                  model_mean.detach(), model_log_variance)
    kl = meanflat(kl) * NAT  # 转换为自然单位

加权目标扩散方法

加权目标方法采用了一种不同的策略，它让模型同时学习预测噪声和原始图像，并通过学习权重来自动平衡这两个目标。

多目标预测架构

加权目标扩散要求模型输出包含三个部分：噪声预测、原始图像预测和权重参数：

class WeightedObjectiveGaussianDiffusion(GaussianDiffusion):
    def __init__(
        self,
        model,
        *args,
        pred_noise_loss_weight = 0.1,
        pred_x_start_loss_weight = 0.1,
        **kwargs
    ):
        super().__init__(model, *args, **kwargs)
        channels = model.channels
        assert model.out_dim == (channels * 2 + 2), '输出维度必须是2*通道数+2'
        
        self.split_dims = (channels, channels, 2)
        self.pred_noise_loss_weight = pred_noise_loss_weight
        self.pred_x_start_loss_weight = pred_x_start_loss_weight

自适应权重学习

模型通过学习softmax归一化的权重来自动决定在每个时间步应该更信任噪声预测还是原始图像预测：

def p_mean_variance(self, *, x, t, clip_denoised, model_output = None):
    model_output = self.model(x, t)
    pred_noise, pred_x_start, weights = model_output.split(self.split_dims, dim=1)
    normalized_weights = weights.softmax(dim=1)
    
    # 从噪声预测重建原始图像
    x_start_from_noise = self.predict_start_from_noise(x, t=t, noise=pred_noise)
    
    # 加权融合两个预测
    x_starts = torch.stack((x_start_from_noise, pred_x_start), dim=1)
    weighted_x_start = einsum('b j h w, b j c h w -> b c h w', 
                             normalized_weights, x_starts)

多损失函数组合

加权目标方法采用三重损失函数，分别针对噪声预测、原始图像预测和加权结果：

def p_losses(self, x_start, t, noise = None, clip_denoised = False):
    noise = default(noise, lambda: torch.randn_like(x_start))
    x_t = self.q_sample(x_start=x_start, t=t, noise=noise)
    
    model_output = self.model(x_t, t)
    pred_noise, pred_x_start, weights = model_output.split(self.split_dims, dim=1)
    
    # 三个损失分量
    noise_loss = F.mse_loss(noise, pred_noise) * self.pred_noise_loss_weight
    x_start_loss = F.mse_loss(x_start, pred_x_start) * self.pred_x_start_loss_weight
    
    # 加权融合损失
    x_start_from_pred_noise = self.predict_start_from_noise(x_t, t, pred_noise)
    weighted_x_start = einsum('b j h w, b j c h w -> b c h w', 
                             weights.softmax(dim=1), 
                             torch.stack((x_start_from_pred_noise, pred_x_start), dim=1))
    
    weighted_x_start_loss = F.mse_loss(x_start, weighted_x_start)
    
    return weighted_x_start_loss + x_start_loss + noise_loss

技术对比与应用场景

为了更清晰地理解这两种方法的差异，下表对比了它们的主要特性：

特性	学习型高斯扩散	加权目标扩散
核心思想	学习方差参数	学习目标权重
模型输出	噪声 + 方差插值	噪声 + 原始图像 + 权重
损失函数	简单损失 + VLB损失	三重加权损失
计算复杂度	中等	较高
训练稳定性	优秀	良好
适用场景	高质量图像生成	多目标平衡

学习型高斯扩散的工作流程

加权目标扩散的决策过程

实践建议与最佳实践

在实际应用中，选择哪种方法取决于具体需求：

1. 学习型高斯扩散更适合追求最高生成质量的场景，特别是在计算资源充足的情况下
2. 加权目标扩散在需要平衡多个训练目标时表现优异，提供了更好的灵活性
3. 对于大多数应用，建议从加权目标方法开始，因其提供了更好的训练稳定性

参数调优建议：

• 学习型扩散的vb_loss_weight通常设置为0.001
• 加权目标扩散的损失权重可根据任务重要性调整
• 两种方法都受益于渐进式训练策略

这两种高级扩散技术代表了生成模型领域的重要进展，通过引入更精细的损失设计和模型架构，显著提升了扩散模型的性能和实用性。

阐明扩散(Elucidated Diffusion)：重新定义扩散模型的设计空间

在扩散模型的发展历程中，Elucidated Diffusion（阐明扩散）代表了从经验性探索到系统性设计的重大转变。这一由Tero Karras等人提出的方法，通过数学上的严格推导和系统化的设计原则，为扩散模型建立了一个统一的理论框架。

核心设计理念

Elucidated Diffusion的核心在于将扩散过程重新表述为一个连续时间的随机微分方程（SDE），并通过精心设计的预处理参数来优化训练和采样过程。与传统的离散时间步方法不同，它采用了一个更加灵活的噪声调度机制。

class ElucidatedDiffusion(nn.Module):
    def __init__(
        self,
        net,
        *,
        image_size,
        channels = 3,
        num_sample_steps = 32,    # 采样步数
        sigma_min = 0.002,        # 最小噪声水平
        sigma_max = 80,           # 最大噪声水平
        sigma_data = 0.5,         # 数据分布标准差
        rho = 7,                  # 控制采样调度
        P_mean = -1.2,            # 训练噪声对数正态分布均值
        P_std = 1.2,              # 训练噪声对数正态分布标准差
        S_churn = 80,             # 随机采样参数
        S_tmin = 0.05,
        S_tmax = 50,
        S_noise = 1.003,
    ):

预处理参数系统

Elucidated Diffusion引入了四个关键的预处理参数，这些参数在数学上经过精心推导，能够显著提升模型的训练稳定性和采样质量：

def c_skip(self, sigma):
    return (self.sigma_data ** 2) / (sigma ** 2 + self.sigma_data ** 2)

def c_out(self, sigma):
    return sigma * self.sigma_data * (self.sigma_data ** 2 + sigma ** 2) ** -0.5

def c_in(self, sigma):
    return 1 * (sigma ** 2 + self.sigma_data ** 2) ** -0.5

def c_noise(self, sigma):
    return log(sigma) * 0.25

这些预处理参数的作用可以总结如下表：

参数	数学表达式	功能描述
c_skip	$\frac{\sigma_{data}^2}{\sigma^2 + \sigma_{data}^2}$	控制跳跃连接权重，平衡原始输入和网络输出
c_out	$\frac{\sigma \cdot \sigma_{data}}{\sqrt{\sigma^2 + \sigma_{data}^2}}$	缩放网络输出，确保数值稳定性
c_in	$\frac{1}{\sqrt{\sigma^2 + \sigma_{data}^2}}$	缩放输入数据，归一化处理
c_noise	$0.25 \cdot \log(\sigma)$	将噪声水平映射到时间嵌入空间

采样调度机制

Elucidated Diffusion采用了一种基于rho参数的采样调度策略，相比传统的线性或余弦调度更加灵活：

def sample_schedule(self, num_sample_steps = None):
    num_sample_steps = default(num_sample_steps, self.num_sample_steps)
    
    N = num_sample_steps
    inv_rho = 1 / self.rho
    
    steps = torch.arange(num_sample_steps, device = self.device, dtype = torch.float32)
    sigmas = (self.sigma_max ** inv_rho + steps / (N - 1) * 
             (self.sigma_min ** inv_rho - self.sigma_max ** inv_rho)) ** self.rho
    
    sigmas = F.pad(sigmas, (0, 1), value = 0.)  # 最后一步sigma值为0
    return sigmas

随机采样与二阶校正

为了提高采样质量，Elucidated Diffusion引入了随机采样机制和二阶校正步骤：

训练过程的数学优化

在训练过程中，Elucidated Diffusion采用了一种基于噪声水平的损失权重机制：

def loss_weight(self, sigma):
    return (sigma ** 2 + self.sigma_data ** 2) * (sigma * self.sigma_data) ** -2

def noise_distribution(self, batch_size):
    return (self.P_mean + self.P_std * torch.randn((batch_size,), device = self.device)).exp()

这种设计确保了在不同噪声水平下的训练稳定性，避免了传统方法中可能出现的梯度爆炸或消失问题。

实际应用示例

以下是一个完整的Elucidated Diffusion使用示例：

import torch
from denoising_diffusion_pytorch import ElucidatedDiffusion, Unet

# 创建U-Net骨干网络
model = Unet(
    dim = 64,
    dim_mults = (1, 2, 4, 8),
    flash_attn = True,
    random_or_learned_sinusoidal_cond = True  # 必须设置为True
)

# 初始化Elucidated Diffusion
diffusion = ElucidatedDiffusion(
    model,
    image_size = 128,
    channels = 3,
    num_sample_steps = 32,    # 仅需32步采样
    sigma_min = 0.002,
    sigma_max = 80,
    sigma_data = 0.5,
    rho = 7
)

# 训练过程
training_images = torch.rand(8, 3, 128, 128)  # 归一化到[0,1]
loss = diffusion(training_images)
loss.backward()

# 采样生成新图像
sampled_images = diffusion.sample(batch_size = 4)
sampled_images.shape  # (4, 3, 128, 128)

性能优势分析

Elucidated Diffusion相比传统扩散模型具有多个显著优势：

1. 采样效率提升：仅需32步即可获得高质量样本，相比DDPM的1000步大幅提升
2. 训练稳定性：通过数学推导的预处理参数，确保训练过程更加稳定
3. 灵活性：rho参数允许根据具体任务调整采样调度策略
4. 理论完备性：基于严格的数学推导，提供了可解释的设计原则

参数调优指南

在实际应用中，以下参数需要根据具体数据集进行调整：

参数	推荐范围	调整建议
sigma_min	0.001-0.01	控制最小噪声水平，影响最终样本质量
sigma_max	40-100	控制最大噪声水平，影响训练稳定性
rho	5-9	控制采样调度曲线形状，影响采样效率
S_churn	40-120	随机采样强度，影响样本多样性

Elucidated Diffusion代表了扩散模型设计从经验性探索向系统性设计的重要转变，为后续的扩散模型研究奠定了坚实的理论基础。通过其数学上的严谨性和实践中的高效性，这一方法在图像生成、音频合成等多个领域都展现出了卓越的性能。

V参数连续时间扩散模型

在扩散模型的发展历程中，V参数化（v-parameterization）代表了一个重要的技术突破，它不仅在渐进式蒸馏方面超越了传统的噪声预测目标，还在Imagen-Video等应用中显著改善了上采样UNet的性能，有效消除了色彩偏移伪影。

V参数化的数学原理

V参数化基于一个关键的数学洞察：通过重新参数化扩散过程，我们可以直接预测一个结合了噪声和原始图像的复合向量。具体来说，V参数定义为：

def p_losses(self, x_start, times, noise = None):
    noise = default(noise, lambda: torch.randn_like(x_start))
    
    x, log_snr, alpha, sigma = self.q_sample(x_start = x_start, times = times, noise = noise)
    
    # V参数的定义：alpha * noise - sigma * x_start
    v = alpha * noise - sigma * x_start
    
    model_out = self.model(x, log_snr)
    
    return F.mse_loss(model_out, v)

这个定义的数学推导可以在原论文的附录D中找到，它提供了一个更稳定的训练目标。

连续时间框架的优势

V参数连续时间扩散模型采用连续时间框架，相比离散时间步长的方法具有显著优势：

实现架构详解

VParamContinuousTimeGaussianDiffusion类的核心架构包含以下几个关键组件：

1. 噪声调度函数

def alpha_cosine_log_snr(t, s = 0.008):
    return -log((torch.cos((t + s) / (1 + s) * math.pi * 0.5) ** -2) - 1, eps = 1e-5)

这个函数实现了余弦噪声调度，提供了平滑的信号噪声比（SNR）变化。

2. 前向扩散过程

def q_sample(self, x_start, times, noise = None):
    noise = default(noise, lambda: torch.randn_like(x_start))
    
    log_snr = self.log_snr(times)
    log_snr_padded = right_pad_dims_to(x_start, log_snr)
    alpha, sigma = sqrt(log_snr_padded.sigmoid()), sqrt((-log_snr_padded).sigmoid())
    x_noised = x_start * alpha + noise * sigma
    
    return x_noised, log_snr, alpha, sigma

3. 反向采样过程

反向采样过程通过p_mean_variance方法计算均值和方差：

def p_mean_variance(self, x, time, time_next):
    log_snr = self.log_snr(time)
    log_snr_next = self.log_snr(time_next)
    c = -expm1(log_snr - log_snr_next)
    
    squared_alpha, squared_alpha_next = log_snr.sigmoid(), log_snr_next.sigmoid()
    squared_sigma, squared_sigma_next = (-log_snr).sigmoid(), (-log_snr_next).sigmoid()
    
    alpha, sigma, alpha_next = map(sqrt, (squared_alpha, squared_sigma, squared_alpha_next))
    
    batch_log_snr = repeat(log_snr, ' -> b', b = x.shape[0])
    pred_v = self.model(x, batch_log_snr)
    
    # 从V参数重建原始图像
    x_start = alpha * x - sigma * pred_v
    
    if self.clip_sample_denoised:
        x_start.clamp_(-1., 1.)
    
    model_mean = alpha_next * (x * (1 - c) / alpha + c * x_start)
    posterior_variance = squared_sigma_next * c
    
    return model_mean, posterior_variance

性能对比分析

为了展示V参数化的优势，我们对比了不同参数化方法的性能：

参数化方法	训练稳定性	采样质量	收敛速度	色彩一致性
噪声预测	中等	良好	慢	一般
数据预测	高	优秀	快	优秀
V参数化	非常高	极佳	最快	极佳

实际应用示例

下面是一个完整的V参数扩散模型使用示例：

import torch
from denoising_diffusion_pytorch import Unet, VParamContinuousTimeGaussianDiffusion

# 创建U-Net模型
model = Unet(
    dim = 64,
    dim_mults = (1, 2, 4, 8),
    flash_attn = True,
    random_or_learned_sinusoidal_cond = True  # 必须启用正弦条件
)

# 创建V参数扩散模型
diffusion = VParamContinuousTimeGaussianDiffusion(
    model,
    image_size = 128,
    channels = 3,
    num_sample_steps = 500,
    clip_sample_denoised = True
)

# 准备训练数据
training_images = torch.rand(8, 3, 128, 128)  # 图像已归一化到[0,1]

# 训练步骤
loss = diffusion(training_images)
loss.backward()

# 采样生成新图像
sampled_images = diffusion.sample(batch_size = 4)
print(sampled_images.shape)  # 输出: (4, 3, 128, 128)

技术细节与最佳实践

1. 模型配置要求

使用V参数化时，U-Net模型必须配置特定的参数：

model = Unet(
    dim = 64,
    dim_mults = (1, 2, 4, 8),
    random_or_learned_sinusoidal_cond = True,  # 必须为True
    self_condition = False,  # 目前不支持自条件
    # 其他参数...
)

2. 训练策略

V参数化模型的训练需要特别注意学习率调度和梯度裁剪：

# 推荐的学习率调度
optimizer = torch.optim.AdamW(diffusion.parameters(), lr=1e-4, weight_decay=1e-6)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=100000)

# 梯度裁剪
torch.nn.utils.clip_grad_norm_(diffusion.parameters(), max_norm=1.0)

3. 采样优化

V参数化支持多种采样策略，包括：

实际应用场景

V参数连续时间扩散模型在以下场景中表现尤为出色：

1. 高分辨率图像生成：相比传统方法，V参数化在生成高分辨率图像时色彩一致性更好
2. 视频生成：在时序数据生成中，V参数化能够保持帧间的一致性
3. 科学计算：在需要精确数值稳定的应用中，连续时间框架更具优势
4. 实时应用：高效的采样过程使其适合实时生成场景

性能优化技巧

为了充分发挥V参数化的潜力，可以考虑以下优化策略：

1. 混合精度训练：使用AMP（Automatic Mixed Precision）加速训练
2. 梯度累积：在小批量情况下使用梯度累积稳定训练
3. 学习率预热：前几个epoch使用较低的学习率
4. 正则化技术：适当使用权重衰减和dropout

通过上述技术细节和最佳实践，V参数连续时间扩散模型能够为各种生成任务提供稳定、高效且高质量的解决方案。

总结

扩散模型变体的发展代表了生成式AI领域的重要进步。从连续时间框架的引入到V参数化的创新，从学习型噪声调度到数学严谨的Elucidated Diffusion，这些技术突破不仅提升了模型性能，还为扩散模型奠定了更坚实的理论基础。未来，随着计算能力的提升和理论的进一步完善，扩散模型将在图像生成、视频合成、科学计算等更多领域发挥重要作用，推动人工智能向更高质量、更高效率的方向发展。

【免费下载链接】denoising-diffusion-pytorch Implementation of Denoising Diffusion Probabilistic Model in Pytorch 项目地址: https://gitcode.com/gh_mirrors/de/denoising-diffusion-pytorch