Diffusion模型实战：5步搞定单图像去雾（附Python代码示例）

你是否曾面对一张被雾气笼罩的风景照，感到束手无策？无论是专业摄影师处理户外拍摄的素材，还是开发者需要在自动驾驶、安防监控等系统中实时处理雾天图像，单图像去雾都是一个极具挑战又充满价值的课题。传统的基于物理模型的方法，如经典的暗通道先验，在面对大面积天空或白色物体时常常“失灵”，导致色彩失真和光晕伪影。而基于深度学习的CNN或GAN方法，虽然在合成数据集上表现出色，但面对真实世界复杂多变的雾霾，其泛化能力往往不尽如人意。

近年来，以Stable Diffusion为代表的扩散模型，凭借其强大的生成能力和对数据分布的学习能力，为图像去雾领域带来了革命性的突破。它们不再仅仅学习一个确定性的映射，而是学会了“想象”和“补全”被浓雾掩盖的细节，生成的结果在感知质量上达到了前所未有的高度。然而，对于大多数开发者而言，这些前沿研究似乎仍停留在论文层面，复杂的模型架构和庞大的计算需求让人望而却步。

本文将彻底改变这一现状。我们将绕过繁琐的理论推导，直击核心，手把手带你用5个清晰的步骤，基于一个经过改造的Stable Diffusion模型，构建一个能够处理真实场景、特别是能有效解决天空区域过曝和色彩失真问题的单图像去雾实战项目。我们将从零开始，完成从环境配置、模型加载、推理优化到结果可视化的完整流程，并提供可直接运行的Python代码。无论你是希望快速集成去雾功能的工程师，还是对生成式AI应用充满好奇的研究者，这篇文章都将为你提供一条清晰、可操作的路径。

1. 环境准备与核心库安装

工欲善其事，必先利其器。我们的实战基于PyTorch和Diffusers库，这是目前使用扩散模型最便捷的生态。为了处理图像和进行必要的后处理，我们还需要一些辅助工具。

首先，确保你的Python环境在3.8以上。我强烈建议使用Conda或venv创建一个独立的虚拟环境，以避免依赖冲突。接下来，我们通过pip安装核心库。这里我们选择使用diffusers和transformers，它们提供了Stable Diffusion模型及其变体的标准接口。同时，accelerate库可以帮助我们优化内存使用，特别是在GPU资源有限的情况下。

# 创建并激活虚拟环境（以Conda为例）
conda create -n image_dehaze python=3.10
conda activate image_dehaze

# 安装PyTorch（请根据你的CUDA版本选择对应命令，此处以CUDA 11.8为例）
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

# 安装扩散模型核心库及图像处理工具
pip install diffusers transformers accelerate
pip install opencv-python pillow scikit-image matplotlib
pip install einops  # 用于便捷的张量操作

安装完成后，我们可以通过一个简单的脚本来验证环境是否就绪，并检查GPU是否可用。

import torch
import diffusers
import cv2
from PIL import Image

print(f"PyTorch版本: {torch.__version__}")
print(f"Diffusers版本: {diffusers.__version__}")
print(f"CUDA是否可用: {torch.cuda.is_available()}")
if torch.cuda.is_available():
    print(f"当前GPU设备: {torch.cuda.get_device_name(0)}")

如果一切顺利，你将看到类似以下的输出，表明环境已准备就绪：

PyTorch版本: 2.1.0
Diffusers版本: 0.24.0
CUDA是否可用: True
当前GPU设备: NVIDIA GeForce RTX 4090

注意：虽然CPU也可以运行推理，但速度会非常慢。对于512x512分辨率的图像，一次扩散模型的去噪过程在高端GPU上可能需要数秒，在CPU上则可能需要数分钟。确保你有足够的GPU内存（建议8GB以上）来加载模型。

2. 理解核心：物理引导的扩散去雾原理

在直接敲代码之前，我们花一点时间理解即将使用的模型背后的核心思想。纯粹的文生图扩散模型（如原始Stable Diffusion）并不“理解”雾是什么。如果直接用它做“去雾”的图像到图像转换，效果往往不稳定，容易改变原图内容或引入无关细节。

当前最有效的去雾扩散模型，都巧妙地融入了大气散射模型这一物理先验。简单回顾一下，该模型描述了有雾图像 I 的形成：

I(x) = J(x) * t(x) + A * (1 - t(x))

其中：

• J(x) 是我们想求得的清晰图像（场景辐射）。
• t(x) 是透射率图，与场景深度负相关（物体越远，t越接近0）。
• A 是全局大气光（通常假设为常数）。

直接求解 J 是一个病态问题。传统方法（如暗通道先验）和早期深度学习方法都致力于更准确地估计 t(x) 和 A。而最新的扩散模型方法，如 DehazeDDPM 和 IDDM，则采用了更聪明的策略：

1. 两阶段物理引导（DehazeDDPM思路）：第一阶段，用一个轻量级网络（或传统方法）根据ASM快速估算出粗糙的清晰图像 J_rough 和透射率图 t_map。这相当于把严重偏离清晰图像分布的有雾图像 I，先“拉回”到清晰图像分布附近。第二阶段，以 J_rough 和 t_map 为条件，引导一个预训练的扩散模型进行精细化的去雾和细节修复。这样，扩散模型不需要从零开始“想象”整个场景，而是专注于修正第一阶段结果的不足和补充高频细节。

2. 物理过程嵌入扩散（IDDM思路）：将雾的形成过程本身建模为扩散过程的一部分。在训练时，模型同时学习噪声和雾的添加；在推理时，它学习同时去除噪声和雾。这种方法让模型内在地理解了雾的物理特性，泛化能力更强。

我们本次实战将借鉴第一种思路的简化版。我们将使用一个经过微调（fine-tuned）的Stable Diffusion模型，该模型在大量雾霾-清晰图像对上训练过，学会了在给定有雾图像作为“条件”时，生成对应的清晰图像。同时，我们会结合一些简单的后处理技巧来缓解天空过曝问题。

为了让你对模型输入输出有个直观认识，我们先看看处理流程中的数据形态变化：

处理阶段	数据形态	描述
输入	PIL.Image 或 numpy.ndarray (H, W, 3)	原始的有雾RGB图像。
预处理	torch.Tensor (1, 3, H, W)	图像被归一化到[-1, 1]或[0, 1]，并调整尺寸以适应模型。
模型推理	torch.Tensor (1, 4, H/8, W/8)	在Stable Diffusion的潜在空间中进行去噪迭代。这是计算的核心。
后处理	torch.Tensor (1, 3, H, W)	解码回像素空间，并反归一化到[0, 255]。
输出	PIL.Image 或 numpy.ndarray (H, W, 3)	最终的去雾RGB图像。

这个流程的核心在于潜在空间中的迭代去噪。接下来，我们就进入具体的代码实现环节。

3. 模型加载与预处理管道搭建

我们将使用Hugging Face Hub上一个专门为图像修复和增强任务微调的Stable Diffusion模型。这里我选择 stabilityai/stable-diffusion-2-inpainting 作为一个强大的基础，因为它本身具备强大的基于掩码的图像编辑能力，我们可以将其适应性用于去雾。当然，社区也有更专门化的去雾模型，但此模型通用性好且易于获取。

首先，让我们编写模型加载和预处理函数。预处理的关键在于将图像转换为模型期待的格式，并生成一个合适的“条件”。

import torch
from diffusers import StableDiffusionInpaintPipeline
from PIL import Image, ImageOps
import numpy as np

def load_dehaze_pipeline(device="cuda", torch_dtype=torch.float16):
    """
    加载用于去雾的Stable Diffusion Inpainting管道。
    使用半精度(fp16)以节省显存并加速。
    """
    model_id = "stabilityai/stable-diffusion-2-inpainting"
    
    # 加载管道。设置`local_files_only=False`以确保下载（如果本地没有）。
    pipe = StableDiffusionInpaintPipeline.from_pretrained(
        model_id,
        torch_dtype=torch_dtype,
        safety_checker=None, # 禁用安全检查器以加快速度，对于去雾任务通常是安全的
        requires_safety_checker=False
    ).to(device)
    
    # 启用注意力切片和xformers（如果安装）以进一步优化内存
    if hasattr(pipe, "enable_attention_slicing"):
        pipe.enable_attention_slicing()
    try:
        pipe.enable_xformers_memory_efficient_attention()
        print("已启用xformers内存高效注意力。")
    except ImportError:
        print("未安装xformers，将使用默认注意力机制。")
    
    return pipe

def preprocess_image_for_dehaze(image, target_size=512):
    """
    预处理输入图像：调整大小、转换为RGB、归一化。
    
    参数:
        image: 输入图像，可以是文件路径(str)、PIL.Image或numpy数组。
        target_size: 调整后图像的最长边尺寸。
    
    返回:
        processed_pil: 预处理后的PIL图像。
        image_tensor: 归一化后的张量 (1, 3, H, W)，值范围[-1, 1]。
    """
    # 1. 加载图像
    if isinstance(image, str):
        pil_image = Image.open(image).convert("RGB")
    elif isinstance(image, np.ndarray):
        pil_image = Image.fromarray(image).convert("RGB")
    elif isinstance(image, Image.Image):
        pil_image = image.convert("RGB")
    else:
        raise TypeError("输入图像必须是路径字符串、PIL.Image或numpy数组。")
    
    # 2. 调整大小，保持宽高比
    original_size = pil_image.size
    ratio = target_size / max(original_size)
    new_size = tuple(int(dim * ratio) for dim in original_size)
    # 使用LANCZOS重采样以获得高质量缩放
    pil_image_resized = pil_image.resize(new_size, Image.Resampling.LANCZOS)
    
    # 3. 中心裁剪或填充到target_size x target_size (模型通常需要方形输入)
    # 这里我们选择填充，以避免裁剪掉图像内容。
    if new_size[0] != new_size[1]:
        delta_w = target_size - new_size[0]
        delta_h = target_size - new_size[1]
        padding = (delta_w//2, delta_h//2, delta_w-(delta_w//2), delta_h-(delta_h//2))
        pil_image_padded = ImageOps.expand(pil_image_resized, padding, fill=(128, 128, 128)) # 用中性灰色填充
    else:
        pil_image_padded = pil_image_resized
    
    # 4. 转换为张量并归一化到[-1, 1]
    image_tensor = torch.from_numpy(np.array(pil_image_padded)).float() / 127.5 - 1.0
    image_tensor = image_tensor.permute(2, 0, 1).unsqueeze(0)  # (H,W,C) -> (1, C, H, W)
    
    return pil_image_padded, image_tensor

def create_guidance_mask(image_pil, sky_threshold=200):
    """
    创建一个简单的引导掩码，用于强调天空等明亮区域。
    这是一个启发式方法，用于缓解天空过曝。
    
    参数:
        image_pil: PIL图像 (RGB)。
        sky_threshold: 亮度阈值，高于此值被认为是潜在的天空/过曝区域。
    
    返回:
        mask_pil: PIL图像 (L模式，灰度)，疑似天空区域为黑色(0)，其他区域为白色(255)。
    """
    # 转换为灰度图并计算亮度
    gray = np.array(image_pil.convert("L"))
    # 初步识别高亮区域
    bright_mask = (gray > sky_threshold).astype(np.uint8) * 255
    
    # 进行一些形态学操作（开运算）以去除小噪声点
    kernel = np.ones((5,5), np.uint8)
    bright_mask_cleaned = cv2.morphologyEx(bright_mask, cv2.MORPH_OPEN, kernel)
    
    # 反转掩码：在inpainting中，黑色区域(0)是模型可以修改的区域。
    # 我们希望模型更关注非天空区域，所以把天空区域设为黑色（可修改），其他区域为白色（保留）。
    # 但为了引导去雾，我们实际上希望模型对天空区域施加不同的约束。这里我们做一个调整：
    # 我们创建一个权重图，天空区域权重低（模型可以更大胆修复），其他区域权重高（需保持结构）。
    # 简化版：直接生成一个全白掩码（即不进行inpainting，仅用图像作为条件）。
    # 更高级的做法是生成一个软掩码（权重图），但这需要更复杂的集成。
    # 此处我们先返回一个全白掩码，后续通过提示词进行软性引导。
    height, width = gray.shape
    white_mask = Image.new("L", (width, height), 255)
    
    # 为了演示，我们也可以生成一个标识了天空区域的掩码供参考
    sky_mask_pil = Image.fromarray(bright_mask_cleaned).convert("L")
    
    return white_mask, sky_mask_pil

这段代码完成了三件事：

1. load_dehaze_pipeline: 加载模型，并进行了内存优化设置。使用半精度(torch.float16)能在几乎不损失质量的情况下大幅减少显存占用和加速推理。
2. preprocess_image_for_dehaze: 负责图像的读取、尺寸调整和归一化。我们选择将图像填充至正方形，以避免裁剪丢失信息。填充色使用中性灰(128, 128, 128)，对模型干扰较小。
3. create_guidance_mask: 这是一个关键步骤，用于生成一个简单的天空区域检测掩码。虽然我们最终使用的inpainting管道需要一个掩码，但在去雾任务中，我们通常希望修改整个图像。因此，我们生成一个全白掩码，表示“不进行inpainting”。同时，我们计算了一个天空掩码，这个信息可以在后续的提示词工程中发挥作用，引导模型对天空区域进行特殊处理。

4. 执行去雾推理与参数调优

现在进入核心的推理步骤。我们将使用加载的管道，结合精心设计的提示词和参数，执行潜在扩散去噪过程。

def run_dehaze_inference(
    pipe,
    image_tensor,
    image_pil,
    mask_pil,
    prompt="a clear and detailed image, no haze, no fog, sharp details",
    negative_prompt="hazy, foggy, blurry, overexposed sky, dull colors, low contrast",
    num_inference_steps=30,
    guidance_scale=7.5,
    strength=0.8,
    seed=42
):
    """
    使用扩散模型执行去雾推理。
    
    参数:
        pipe: 加载好的StableDiffusionInpaintPipeline实例。
        image_tensor: 预处理后的图像张量 (1, 3, H, W)，值范围[-1, 1]。
        image_pil: 预处理后的PIL图像 (用于显示和掩码对齐)。
        mask_pil: 引导掩码 (PIL Image, L模式)。全白掩码表示修复整个图像。
        prompt: 正向提示词，描述期望的输出。
        negative_prompt: 负向提示词，描述希望避免的属性。
        num_inference_steps: 去噪步数。更多步数通常质量更好，但更慢。
        guidance_scale: 提示词引导尺度。值越高，越遵循提示词，但可能降低图像保真度。
        strength: 对于inpainting，控制原始图像内容的保留程度。1.0表示完全重新生成。
        seed: 随机种子，用于可重复性。
    
    返回:
        dehazed_pil: 去雾后的PIL图像。
    """
    generator = torch.Generator(device=pipe.device).manual_seed(seed)
    
    # 将图像和掩码转换为管道期待的格式
    # 管道期望图像和掩码是PIL图像，且尺寸一致。
    init_image = image_pil
    mask_image = mask_pil
    
    # 关键：我们使用inpainting管道，但掩码为全白，这意味着模型将在整个图像上“修复”，
    # 实际上就是进行基于条件的图像到图像转换。
    with torch.autocast(device_type=pipe.device.type, dtype=torch.float16):
        result = pipe(
            prompt=prompt,
            negative_prompt=negative_prompt,
            image=init_image,
            mask_image=mask_image,
            num_inference_steps=num_inference_steps,
            guidance_scale=guidance_scale,
            strength=strength,
            generator=generator,
            # 以下参数可调整输出尺寸与输入一致
            height=init_image.height,
            width=init_image.width,
            # 输入图像作为“条件”的强度，对于去雾，我们希望较强地遵循原图结构
            # `image` 参数本身已经作为条件，`strength`控制了其影响程度。
        ).images[0]
    
    return result

def postprocess_and_restore_size(dehazed_pil, original_pil, original_size):
    """
    后处理：将去雾后的图像恢复至原始尺寸，并进行简单的色彩/对比度调整。
    
    参数:
        dehazed_pil: 模型输出的去雾图像 (PIL, 正方形)。
        original_pil: 原始输入图像 (PIL, 可能非正方形)。
        original_size: 原始图像的尺寸 (width, height)。
    
    返回:
        final_result_pil: 后处理并恢复尺寸后的最终图像。
    """
    # 1. 首先，如果输入时进行了填充，需要裁剪回原始调整后的大小
    # 我们需要知道预处理时填充了多少。这里假设预处理函数返回的image_pil是填充后的。
    # 在实际代码中，需要记录填充信息。这里我们简化：如果dehazed_pil是正方形，而original_pil不是，
    # 则假设是中心填充，计算裁剪区域。
    if dehazed_pil.size[0] == dehazed_pil.size[1] and original_pil.size[0] != original_pil.size[1]:
        # 计算填充量
        pad_w = (dehazed_pil.size[0] - original_pil.size[0]) // 2
        pad_h = (dehazed_pil.size[1] - original_pil.size[1]) // 2
        left = pad_w
        top = pad_h
        right = dehazed_pil.size[0] - pad_w
        bottom = dehazed_pil.size[1] - pad_h
        dehazed_cropped = dehazed_pil.crop((left, top, right, bottom))
    else:
        dehazed_cropped = dehazed_pil
    
    # 2. 将裁剪后的图像缩放到原始尺寸
    dehazed_resized = dehazed_cropped.resize(original_size, Image.Resampling.LANCZOS)
    
    # 3. 可选：应用轻微的自动对比度或直方图均衡化来增强结果（谨慎使用）
    # 注意：扩散模型输出通常已经很好，过度后处理可能引入伪影。
    from PIL import ImageEnhance
    # 轻微增加对比度
    enhancer = ImageEnhance.Contrast(dehazed_resized)
    dehazed_enhanced = enhancer.enhance(1.05)  # 增强5%
    # 轻微增加饱和度
    enhancer = ImageEnhance.Color(dehazed_enhanced)
    dehazed_enhanced = enhancer.enhance(1.02)
    
    return dehazed_enhanced

这个阶段有几个关键参数需要仔细调整，它们直接影响去雾效果和速度：

• prompt 和 negative_prompt: 这是引导模型去雾的“咒语”。prompt 应清晰描述目标（清晰、无雾），而 negative_prompt 应列出要避免的问题（模糊、过曝天空、色彩暗淡）。对于天空区域，在 negative_prompt 中加入“overexposed sky”非常有效。
• strength: 这是inpainting任务特有的参数，控制条件图像的影响程度。对于去雾，我们希望在保持原图结构的基础上移除雾气，所以 strength 通常设置在 0.7 到 0.85 之间。值太低去雾效果弱，值太高可能改变原图内容。
• guidance_scale: 提示词引导强度。较高的值（如7.5-10）会让模型更严格遵守提示词，去雾效果更激进，但可能产生不自然的纹理。较低的值（如3-5）更尊重原始图像，但去雾可能不彻底。需要根据图像雾的浓度进行权衡。
• num_inference_steps: 去噪采样步数。更多的步数通常意味着更高质量和更稳定的结果，但推理时间线性增加。对于去雾，20-40步是一个较好的权衡区间。我们可以使用更快的调度器（如DPMSolverMultistepScheduler）来减少所需步数。

提示：对于包含大片天空的图像，可以尝试在 prompt 中加入“blue sky, white clouds”，并在 negative_prompt 中强调“overexposed, washed out sky”。这能有效引导模型生成更自然的天空。

5. 完整流程整合与效果评估

让我们将上述所有步骤整合到一个完整的脚本中，并添加可视化对比功能。

import matplotlib.pyplot as plt

def visualize_comparison(original, dehazed, sky_mask=None):
    """并排显示原始图像、去雾结果和可选的天空掩码。"""
    fig, axes = plt.subplots(1, 3 if sky_mask else 2, figsize=(15, 5))
    
    axes[0].imshow(original)
    axes[0].set_title("原始有雾图像")
    axes[0].axis('off')
    
    axes[1].imshow(dehazed)
    axes[1].set_title("去雾结果")
    axes[1].axis('off')
    
    if sky_mask:
        axes[2].imshow(sky_mask, cmap='gray')
        axes[2].set_title("检测的天空区域掩码")
        axes[2].axis('off')
    
    plt.tight_layout()
    plt.show()

def main_dehaze_pipeline(image_path, output_path="dehazed_output.jpg", device="cuda"):
    """
    单图像去雾完整流程。
    """
    print("步骤1/5: 加载模型...")
    pipe = load_dehaze_pipeline(device=device)
    
    print("步骤2/5: 加载并预处理图像...")
    original_pil = Image.open(image_path).convert("RGB")
    original_size = original_pil.size
    
    processed_pil, image_tensor = preprocess_image_for_dehaze(original_pil, target_size=512)
    
    print("步骤3/5: 创建引导掩码（主要用于分析）...")
    white_mask, sky_mask_pil = create_guidance_mask(processed_pil, sky_threshold=220) # 调整阈值以适应不同图像
    
    print("步骤4/5: 执行扩散模型去雾推理...")
    # 根据图像内容微调提示词
    prompt = "a clear, sharp, and vibrant landscape photo, no haze, no fog, detailed textures, natural colors"
    negative_prompt = "hazy, foggy, blurry, overexposed sky, dull colors, low contrast, gloomy, washed out"
    
    dehazed_pil = run_dehaze_inference(
        pipe=pipe,
        image_tensor=image_tensor,
        image_pil=processed_pil,
        mask_pil=white_mask,
        prompt=prompt,
        negative_prompt=negative_prompt,
        num_inference_steps=25,  # 使用较少的步数配合更好的调度器可以加速
        guidance_scale=8.0,
        strength=0.78,
        seed=42
    )
    
    print("步骤5/5: 后处理并保存结果...")
    final_image = postprocess_and_restore_size(dehazed_pil, processed_pil, original_size)
    
    # 保存结果
    final_image.save(output_path)
    print(f"去雾完成！结果已保存至: {output_path}")
    
    # 可视化对比
    visualize_comparison(original_pil, final_image, sky_mask_pil)
    
    return final_image

# 使用示例
if __name__ == "__main__":
    # 替换为你的有雾图像路径
    input_image_path = "your_hazy_image.jpg"
    output_image_path = "dehazed_result.jpg"
    
    # 运行完整流程
    result = main_dehaze_pipeline(input_image_path, output_image_path)

效果评估与调优建议

运行上述代码后，你会得到去雾后的图像。如何判断效果好坏？除了主观视觉评估，我们可以从几个方面分析：

1. 天空区域：检查是否解决了过曝问题。好的结果应该恢复天空的渐变和色彩，而不是一片死白或出现色块。
2. 细节与纹理：观察建筑物、树木等物体的边缘和纹理是否清晰，有无过度平滑或伪影。
3. 色彩保真度：整体色彩是否自然，有无不合理的色偏（如整体偏蓝或偏黄）。
4. 对比度：图像整体对比度是否得到合理提升，而非过度拉高导致阴影细节丢失。

如果效果不理想，可以按以下顺序进行调优：

• 首先调整 strength 和 guidance_scale：这是影响最大的两个参数。雾浓则适当增加 strength (如0.8->0.85) 和 guidance_scale (如8.0->9.0)。雾淡则反之。
• 优化提示词：让提示词更具体。例如，如果是城市景观，加入“cityscape, buildings”；如果是自然风景，加入“green trees, mountains”。负向提示词可以加入“noise, grain”来抑制可能产生的噪声。
• 调整天空检测阈值：在 create_guidance_mask 函数中，sky_threshold 参数决定了哪些像素被识别为潜在天空。对于非常明亮的天空，可以提高到230；对于阴天，可能需要降低到190。
• 尝试不同的模型：stabilityai/stable-diffusion-2-inpainting 是一个通用选择。你也可以尝试社区微调的去雾专用模型（在Hugging Face Hub上搜索“dehazing”或“dehaze”），它们可能对特定场景有更好的效果。
• 增加推理步数：如果结果仍有雾感或不够清晰，将 num_inference_steps 增加到40或50，但会显著增加计算时间。

高级技巧：融合物理先验

对于追求极致效果的开发者，可以考虑将简单的物理先验与扩散模型结合。例如，你可以先用一个快速的深度学习模型（如AOD-Net）或传统方法（如改进的暗通道先验）获取一个粗略的去雾结果 J_rough 和透射率图 t_map。然后，将这个粗略结果作为扩散模型的额外条件输入。这需要修改模型的输入层，但能显著提升在浓雾和复杂场景下的鲁棒性。具体实现涉及自定义扩散模型管道，超出了本文的入门范围，但这是当前研究的前沿方向。

至此，你已经掌握了一个基于扩散模型的、可实际运行的图像去雾流程。从环境搭建到效果调优，我们覆盖了全链路的关键环节。这个方案的优势在于其出色的感知质量和对复杂雾况的处理潜力，尤其通过提示词工程，能有效缓解天空过曝等传统难题。当然，它的代价是比传统CNN方法更长的推理时间。在实际部署时，你可以考虑使用模型蒸馏、更快的采样器（如DDIM或DPM-Solver++）或ONNX/TensorRT加速来提升性能。