简介：本资源是一套基于PyTorch实现的对偶生成对抗网络（Dual GAN）图像去雾完整项目，专为计算机相关专业本科生毕业设计与课程实践打造，已通过导师评审并获99分高分。项目聚焦真实场景下的雾霾图像复原任务，涵盖模型构建、训练、推理与可视化全流程，代码结构清晰、注释详尽，小白可直接运行调试。压缩包共25个文件，含10个核心Python脚本（如Generator.py、Discriminator.py、train.py、predict.py等）、6张训练损失曲线与效果对比图（PNG）、5张测试输入/输出样例图（JPG）、2个预训练模型权重（.pkl）、README说明文档及Git配置文件，整体大小21.23MB。目前已有143人学习下载，配套文档详细阐述算法原理、数据预处理逻辑、超参设置依据及常见问题排查方法，特别适合毕设开题、中期实现与答辩演示阶段使用。
1. 项目背景与核心价值：为什么用对偶GAN去雾？
图像去雾，或者说图像去雾霾，是计算机视觉里一个老生常谈但又极具实用价值的问题。无论是自动驾驶的感知系统、无人机航拍，还是手机摄影的算法优化，清晰、无雾的图像都是后续目标检测、场景理解等高级任务的基础。传统的去雾方法，比如基于暗通道先验（DCP）或者大气散射物理模型的算法，往往依赖于一些强假设，比如场景深度变化平缓、天空区域存在等。这些假设在复杂多变的真实场景里很容易失效，导致去雾结果要么残留雾气，要么颜色失真，甚至引入大量噪声和光晕伪影。
这几年，深度学习，尤其是生成对抗网络（GAN），给图像复原领域带来了革命性的变化。GAN的思路很巧妙：它不直接去拟合一个从有雾到无雾的确定性映射，而是训练一个生成器去“伪造”清晰图像，同时训练一个判别器去鉴别图像是“真清晰”还是“假清晰”。两者在对抗中共同进化，最终生成器能产出以假乱真的清晰图。但标准GAN在图像翻译任务上有个顽疾——模式崩溃。简单说，生成器可能会找到一种“万能”的清晰图模式来糊弄判别器，导致所有输入都生成差不多的输出，丢失了输入图像本身的细节和多样性。
对偶生成对抗网络（DualGAN）就是为了解决这个问题而生的。它的核心思想是引入“循环一致性”。想象一下翻译任务：英文到中文，再中文回英文，如果来回翻译后意思没变，那说明这个翻译过程是可靠的。DualGAN在图像去雾上就用了这招。它训练两个生成器：一个负责从有雾图到清晰图（去雾），另一个负责从清晰图到有雾图（加雾）。同时，它还有两个判别器，分别判断清晰图和有雾图的真伪。关键约束在于，一张清晰图经过“加雾-去雾”循环后，应该能回到它自己；一张有雾图经过“去雾-加雾”循环后，也应该能回到原图。这个循环一致性损失极大地稳定了训练过程，迫使生成器必须学习到图像内容本身的结构信息，而不仅仅是学会生成某一种“清晰”的纹理，从而有效缓解模式崩溃，生成质量更高、细节保持更好的去雾结果。
所以，这个“基于PyTorch实现对偶生成对抗网络来实现图像去雾”的项目，其核心价值就在于提供了一个端到端、高质量、且易于理解和复现的深度学习去雾解决方案。它不仅仅是一堆代码，更是一个完整的工程实践包，包含了从数据准备、模型定义、训练策略到推理部署的全链条。对于想入门图像复原的研究者，或者需要在产品中集成去雾功能的工程师来说，这样一个带有预训练模型和详细说明的项目，能节省大量从零搭建、调参、Debug的时间，直接切入核心问题。
2. 环境搭建与依赖库详解：避开PyTorch安装的那些坑
拿到源码的第一步，肯定是把环境跑起来。这个项目基于PyTorch，所以环境的正确搭建是后续一切工作的基石。很多人觉得装个PyTorch有什么难的，pip install torch不就完了？但恰恰是这一步，坑最多，尤其是对于需要GPU加速的用户。
2.1 核心依赖清单与版本管理
首先，我们明确项目需要哪些核心的Python库。一个典型的PyTorch深度学习项目，其requirements.txt文件可能包含以下内容：
torch>=1.9.0 torchvision>=0.10.0 numpy>=1.19.5 opencv-python>=4.5.3 Pillow>=8.3.1 tensorboard>=2.7.0 matplotlib>=3.4.3 tqdm>=4.62.0- torch & torchvision: 项目的核心框架。版本选择至关重要。PyTorch官网提供了详细的配置器，你需要根据你的CUDA版本和操作系统来选择正确的安装命令。比如，如果你用的是CUDA 11.3，那么命令可能是
pip install torch==1.12.1+cu113 torchvision==0.13.1+cu113 --extra-index-url https://download.pytorch.org/whl/cu113。绝对不要盲目安装最新版，CUDA、PyTorch、显卡驱动三者版本必须兼容。 - opencv-python (cv2): 用于图像的读取、显示、以及一些基础的颜色空间转换、滤波操作。在数据预处理和后处理中非常常用。
- Pillow (PIL): Python图像处理的标准库之一，和OpenCV互为补充，有时在图像格式和通道顺序（RGB vs BGR）上需要注意。
- tensorboard: 模型训练的可视化神器。可以实时查看损失曲线、生成的图像样本，对于监控训练过程、判断是否过拟合或欠拟合不可或缺。
- matplotlib & tqdm: 前者用于绘图，后者用于在循环中显示进度条，提升交互体验。
注意：强烈建议使用虚拟环境（如
conda或venv）来管理项目的依赖。这能避免不同项目间库版本的冲突。一个常见的做法是：conda create -n dehaze_env python=3.8然后conda activate dehaze_env，再安装上述依赖。
2.2 GPU版本PyTorch安装实战指南
如果你的机器有NVIDIA显卡，并且希望利用GPU加速训练（这能节省数倍甚至数十倍的时间），那么安装GPU版本的PyTorch是必须的。步骤如下：
- 确认CUDA版本：在命令行输入
nvidia-smi。右上角会显示CUDA Version，例如12.2。这个版本是你的驱动支持的最高CUDA版本，不代表你已安装的CUDA运行时版本。更准确的方法是看系统环境，或者运行nvcc --version（如果安装了CUDA Toolkit）。对于PyTorch安装，我们通常参考驱动支持的版本即可。 - 前往PyTorch官网获取安装命令：访问 pytorch.org ，在“Get Started”区域，选择你的系统（Linux、Windows、Mac）、包管理工具（pip或conda）、语言（Python）、以及计算平台（CUDA版本）。例如，选择
Linux,Pip,Python,CUDA 11.8，它会生成命令：pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118。 - 执行安装并验证：在激活的虚拟环境中运行上一步得到的命令。安装完成后，在Python中运行以下代码验证：
如果import torch print(torch.__version__) # 打印PyTorch版本 print(torch.cuda.is_available()) # 应返回True print(torch.cuda.get_device_name(0)) # 打印你的GPU型号torch.cuda.is_available()返回True，恭喜你，GPU环境配置成功。如果返回False，请检查：1) PyTorch版本是否与CUDA版本匹配；2) 显卡驱动是否足够新；3) 是否在正确的虚拟环境中。
2.3 常见环境问题排查
- “No module named ‘torch’”: 说明PyTorch没有安装到当前Python环境。检查是否激活了正确的虚拟环境，或者尝试用
python -m pip install来安装。 - CUDA版本不匹配导致的运行时错误：错误信息可能包含“CUDA error”, “invalid device function”等。这几乎总是因为PyTorch编译的CUDA版本高于你系统实际的CUDA运行时版本。解决方法是卸载后，严格按照你系统支持的CUDA版本重新安装PyTorch。
- 内存不足（OOM）：训练时如果报“CUDA out of memory”，需要减小
batch_size。在代码的配置部分（通常是config.py或训练脚本的开头），找到batch_size参数，将其调小（如从16调到8、4），直到能正常运行。
3. 项目结构解析与核心代码走读
一个组织良好的项目结构，能让你快速定位功能模块，理解数据流。这个去雾项目的典型结构可能如下：
dehaze_dualgan_project/ ├── data/ │ ├── train/ # 训练集，内部可能有 haze/（有雾图）和 clear/（清晰图）子文件夹 │ └── test/ # 测试集 ├── models/ │ ├── generators.py # 定义生成器网络（U-Net等） │ ├── discriminators.py # 定义判别器网络（PatchGAN等） │ └── dualgan.py # 整合生成器、判别器，定义前向传播流程 ├── utils/ │ ├── dataset.py # 自定义Dataset类，负责数据加载和预处理 │ ├── losses.py # 定义各种损失函数（对抗损失、循环一致性损失、身份损失等） │ └── image_utils.py # 图像处理工具函数（归一化、保存等） ├── configs/ │ └── default.yaml # 配置文件，集中管理超参数（学习率、epoch数等） ├── train.py # 模型训练主脚本 ├── test.py # 模型测试/推理脚本 ├── inference.py # 单张图像去雾演示脚本 ├── requirements.txt # 项目依赖 └── README.md # 项目说明文档3.1 数据加载器（Dataset）的奥秘
数据是模型的燃料。dataset.py里的DehazeDataset类继承自torch.utils.data.Dataset，它的核心是__getitem__方法。这个方法决定了模型“吃”进去的数据是什么样子的。
class DehazeDataset(Dataset): def __init__(self, haze_dir, clear_dir, transform=None): self.haze_paths = sorted(glob.glob(os.path.join(haze_dir, '*.jpg'))) self.clear_paths = sorted(glob.glob(os.path.join(clear_dir, '*.jpg'))) self.transform = transform # 通常需要确保有雾图和清晰图文件名一一对应 def __getitem__(self, idx): haze_img = Image.open(self.haze_paths[idx]).convert('RGB') clear_img = Image.open(self.clear_paths[idx]).convert('RGB') if self.transform: haze_img = self.transform(haze_img) clear_img = self.transform(clear_img) return {'haze': haze_img, 'clear': clear_img}这里有几个关键点：
- 图像配对：有雾图和清晰图必须严格按文件名或顺序对应。通常数据集会提供成对的图像。如果是不成对的数据，则需要使用CycleGAN风格的算法，但本项目是对偶GAN，通常要求配对数据。
- 数据预处理（Transform）：这是影响模型性能的关键。常见的预处理流水线包括：
**归一化到[-1, 1]**是GAN训练中的常见操作，因为生成器的输出层（如Tanh）的值域就是[-1, 1]，这有利于训练的稳定性。transform = transforms.Compose([ transforms.Resize((256, 256)), # 统一尺寸 transforms.RandomHorizontalFlip(p=0.5), # 随机水平翻转，数据增强 transforms.RandomCrop(224), # 随机裁剪，数据增强 transforms.ToTensor(), # 将PIL图像或numpy数组转换为Tensor，并缩放到[0,1] transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) # 归一化到[-1, 1] ])
3.2 生成器与判别器的网络架构
在models/generators.py中，你会看到生成器的定义。对于图像到图像的翻译任务，U-Net或其变体是最常用的生成器架构。它通过编码器-解码器结构，并辅以跳跃连接，能很好地保留输入图像的细节信息。
import torch.nn as nn class UnetGenerator(nn.Module): def __init__(self, input_channels=3, output_channels=3, num_filters=64): super().__init__() # 编码器部分 (下采样) self.down1 = nn.Sequential(nn.Conv2d(input_channels, num_filters, 4, 2, 1), nn.LeakyReLU(0.2)) self.down2 = self._down_block(num_filters, num_filters*2) # 通道数翻倍，尺寸减半 self.down3 = self._down_block(num_filters*2, num_filters*4) self.down4 = self._down_block(num_filters*4, num_filters*8) # 瓶颈层 self.bottleneck = nn.Sequential(nn.Conv2d(num_filters*8, num_filters*8, 4, 2, 1), nn.ReLU()) # 解码器部分 (上采样) + 跳跃连接 self.up1 = self._up_block(num_filters*16, num_filters*4) # 输入是上一层的输出和对应编码器层的特征concat self.up2 = self._up_block(num_filters*8, num_filters*2) self.up3 = self._up_block(num_filters*4, num_filters) self.up4 = self._up_block(num_filters*2, output_channels, final_layer=True) def _down_block(self, in_c, out_c): return nn.Sequential( nn.Conv2d(in_c, out_c, 4, 2, 1, bias=False), nn.BatchNorm2d(out_c), nn.LeakyReLU(0.2, inplace=True) ) def _up_block(self, in_c, out_c, final_layer=False): layers = [ nn.ConvTranspose2d(in_c, out_c, 4, 2, 1, bias=False), nn.BatchNorm2d(out_c), nn.ReLU(inplace=True) if not final_layer else nn.Tanh() # 最后一层用Tanh ] return nn.Sequential(*layers) def forward(self, x): # 前向传播，实现跳跃连接 d1 = self.down1(x) d2 = self.down2(d1) d3 = self.down3(d2) d4 = self.down4(d3) bottleneck = self.bottleneck(d4) u1 = self.up1(torch.cat([bottleneck, d4], dim=1)) # 跳跃连接：concat u2 = self.up2(torch.cat([u1, d3], dim=1)) u3 = self.up3(torch.cat([u2, d2], dim=1)) u4 = self.up4(torch.cat([u3, d1], dim=1)) return u4而在models/discriminators.py中，判别器通常采用PatchGAN的结构。它不像传统判别器那样输出一个“真/假”的标量，而是输出一个N x N的矩阵，其中每个元素对应输入图像的一个局部区域（patch）为“真”的概率。这种结构让判别器专注于图像局部纹理的真实性，迫使生成器在细节上也做得更好。
class PatchGANDiscriminator(nn.Module): def __init__(self, input_channels=3, num_filters=64, n_layers=3): super().__init__() sequence = [ nn.Conv2d(input_channels, num_filters, 4, 2, 1), nn.LeakyReLU(0.2, inplace=True) ] # 逐步增加通道数，减小空间尺寸 nf_mult = 1 for n in range(1, n_layers): nf_mult_prev = nf_mult nf_mult = min(2 ** n, 8) sequence += [ nn.Conv2d(num_filters * nf_mult_prev, num_filters * nf_mult, 4, 2, 1, bias=False), nn.BatchNorm2d(num_filters * nf_mult), nn.LeakyReLU(0.2, inplace=True) ] # 最后一层，输出一个特征图 nf_mult_prev = nf_mult nf_mult = min(2 ** n_layers, 8) sequence += [ nn.Conv2d(num_filters * nf_mult_prev, num_filters * nf_mult, 4, 1, 1, bias=False), nn.BatchNorm2d(num_filters * nf_mult), nn.LeakyReLU(0.2, inplace=True) ] sequence += [nn.Conv2d(num_filters * nf_mult, 1, 4, 1, 1)] # 输出通道为1 self.model = nn.Sequential(*sequence) def forward(self, x): return self.model(x) # 输出形如 [batch_size, 1, H, W] 的特征图3.3 对偶GAN的核心：损失函数与训练循环
losses.py和train.py是项目的灵魂。对偶GAN的损失函数通常由三部分组成：
对抗损失（Adversarial Loss）：让生成器G（去雾）和F（加雾）生成的图像骗过各自的判别器D_Y和D_X。通常使用最小二乘GAN（LSGAN）的损失，因为它比原始GAN的交叉熵损失更稳定。
def gan_loss(pred, target_is_real): # target_is_real 为 True 时，希望pred接近1；为False时，希望pred接近0 target_tensor = torch.tensor(1.0) if target_is_real else torch.tensor(0.0) target_tensor = target_tensor.expand_as(pred).to(pred.device) loss = F.mse_loss(pred, target_tensor) return loss循环一致性损失（Cycle Consistency Loss）：这是对偶GAN的核心。确保清晰图X经过G（去雾）和F（加雾）的循环后能重建回X，有雾图Y经过F和G的循环后能重建回Y。通常使用L1损失来衡量重建图像与原图的差异。
cycle_loss = F.l1_loss(fake_clear, real_clear) + F.l1_loss(fake_haze, real_haze)身份损失（Identity Loss，可选但推荐）：将清晰图输入生成器G，希望输出还是清晰图；将有雾图输入生成器F，希望输出还是有雾图。这有助于生成器学习“什么都不做”的恒等映射，在训练初期起到稳定作用，并有助于保持输入图像的色彩。
identity_loss = F.l1_loss(G(real_clear), real_clear) + F.l1_loss(F(real_haze), real_haze)
在train.py的训练循环中，你会看到交替优化生成器和判别器的过程。通常，判别器的训练步数（n_critic）可以设置为1，即每训练一次生成器就训练一次判别器。优化器常用Adam，初始学习率如2e-4。学习率调度器（如lr_scheduler.StepLR）可以在训练后期降低学习率，帮助模型收敛到更好的局部最优解。
4. 模型训练全流程与调参实战经验
有了代码和理论，接下来就是漫长的训练过程。这个过程充满了不确定性，也是最能积累经验的地方。
4.1 数据准备与预处理技巧
高质量的训练数据是成功的一半。对于图像去雾，你需要成对的数据集，例如RESIDE（Indoor/Outdoor）、D-HAZY、O-HAZE等。下载后，你需要将它们整理成项目要求的格式，通常是两个文件夹trainA（有雾）和trainB（清晰），并且图像文件名要一一对应。
数据增强是防止过拟合、提升模型泛化能力的关键。除了代码中提到的随机翻转、裁剪，还可以尝试：
- 颜色抖动：轻微调整图像的亮度、对比度、饱和度和色调，模拟不同光照条件。
- 添加噪声：在清晰图像上添加极少量高斯噪声，可以让模型对输入噪声更鲁棒。
- 注意：数据增强通常只应用于训练集，测试集和验证集应保持原始状态，以评估模型的真实性能。
4.2 超参数调优：从混沌到有序
训练深度学习模型就像炼丹，超参数就是你的药材配方。以下是一些核心超参数及其影响：
| 超参数 | 典型值/范围 | 作用与影响 | 调整策略 |
|---|---|---|---|
| 学习率 (lr) | 1e-4 到 2e-4 | 控制参数更新步长。太大易震荡不收敛，太小收敛慢。 | 这是最重要的参数。可从2e-4开始，用学习率预热（warmup）策略，后期配合调度器衰减。 |
| 批大小 (batch_size) | 1, 2, 4, 8, 16 | 一次迭代用于更新梯度的样本数。受GPU内存限制。 | 在内存允许下尽可能大。大的batch_size使梯度估计更准，训练更稳定，但可能降低泛化性。 |
| 训练轮数 (epochs) | 50 - 200+ | 整个数据集遍历的次数。 | 观察训练和验证集损失曲线。当验证损失不再下降甚至上升时（过拟合），应早停。 |
| 生成器 vs 判别器训练比例 | 1:1 (n_critic=1) | 控制判别器和生成器的更新频率。 | 如果判别器太强（D_loss很快到0），可以增加n_critic（如5），让判别器多训练几次。 |
| 损失权重 (lambda_cycle, lambda_id) | 10.0, 0.5 | 控制循环一致性损失和身份损失相对于对抗损失的权重。 | lambda_cycle通常设为10，确保循环约束足够强。lambda_id可以设为0.5或5，测试其对色彩保持的影响。 |
| 优化器 (Adam) | beta1=0.5, beta2=0.999 | Adam优化器的动量参数。 | beta1=0.5是GAN训练中的经验值，有助于稳定训练。通常不需改动。 |
我的调参经验：
- 先让小模型跑起来：开始时，可以降低图像分辨率（如128x128），减少网络层数，用很小的batch_size（如1或2）快速跑几个epoch，验证整个训练流程是否通畅，损失是否在下降。
- 监控是关键：一定要使用Tensorboard。同时监控生成器损失（G_loss）、判别器损失（D_loss）、循环一致性损失（cycle_loss）。理想情况是G_loss和D_loss在动态平衡中缓慢下降，cycle_loss稳步下降并保持在一个较低水平。如果D_loss迅速降到0而G_loss飙升，说明判别器太强，模式崩溃了。
- 耐心与早停：GAN训练可能需要很多轮才能看到质量不错的生成结果。不要因为前10个epoch生成的图像是模糊的或奇怪的就放弃。但也要设置早停（Early Stopping），如果连续20个epoch验证集上的某个指标（如PSNR）没有提升，就停止训练，防止过拟合。
4.3 训练过程中的问题诊断与解决
训练时你可能会遇到以下“症状”：
- 生成图像模糊：这是初期常见现象。可能原因：1) 循环一致性损失权重
lambda_cycle太大，模型过于注重重建而牺牲了清晰度。可以尝试适当降低。2) 生成器能力不足。可以尝试加深或加宽U-Net。3) 判别器太弱，无法给生成器提供有效的梯度。可以尝试让判别器结构更深一些，或者增加n_critic。 - 生成图像颜色失真：比如整体偏绿或偏蓝。可能原因：1) 身份损失权重
lambda_id不够。适当增加它，可以帮助模型保持输入图像的色彩分布。2) 数据预处理中归一化的均值/方差设置不对。检查训练集图像的统计值。 - 训练不稳定，损失剧烈震荡：可能原因：1) 学习率太高。逐步调低学习率。2) 批归一化（BatchNorm）层在GAN中有时会导致不稳定。可以尝试使用实例归一化（InstanceNorm）或谱归一化（Spectral Norm）来替代判别器中的BatchNorm。3) 使用梯度裁剪（Gradient Clipping）限制梯度范围。
5. 模型测试、推理与效果评估
模型训练完成后，我们需要知道它到底好不好用。这涉及到模型加载、单张/批量图像推理，以及定性和定量评估。
5.1 加载预训练模型进行推理
项目提供的inference.py或test.py脚本通常包含了模型加载和推理的代码。核心步骤如下：
import torch from models.generators import UnetGenerator from PIL import Image import torchvision.transforms as transforms # 1. 定义设备并加载模型 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') G = UnetGenerator(input_channels=3, output_channels=3).to(device) # 去雾生成器 # 加载预训练权重 checkpoint = torch.load('./pretrained_models/best_generator.pth', map_location=device) G.load_state_dict(checkpoint['model_state_dict']) G.eval() # 切换到评估模式，这会关闭Dropout和BatchNorm的统计更新 # 2. 定义与训练时一致的数据预处理（除数据增强外） transform = transforms.Compose([ transforms.Resize((256, 256)), # 需要与训练时输入尺寸一致 transforms.ToTensor(), transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) ]) # 3. 加载并预处理单张图像 haze_image = Image.open('test_haze.jpg').convert('RGB') haze_tensor = transform(haze_image).unsqueeze(0).to(device) # 增加batch维度 # 4. 前向传播（无需计算梯度） with torch.no_grad(): output_tensor = G(haze_tensor) # 5. 后处理：将输出Tensor转换回PIL图像 # 反归一化：output = (output_tensor * 0.5 + 0.5).clamp(0, 1) output_np = output_tensor.squeeze().cpu().numpy().transpose(1, 2, 0) # CHW -> HWC output_np = (output_np * 0.5 + 0.5).clip(0, 1) * 255.0 output_image = Image.fromarray(output_np.astype('uint8')) output_image.save('dehazed_result.jpg')注意：务必确保推理时的预处理（特别是Resize的尺寸和Normalize的参数）与训练时完全一致，否则模型性能会严重下降。
5.2 客观评价指标：PSNR与SSIM
除了肉眼观察，我们还需要用数字来衡量去雾效果。最常用的两个全参考图像质量评价指标是：
- 峰值信噪比（PSNR）：衡量去雾图像与真实清晰图像之间的像素级误差。值越高，表示图像失真越小。计算公式基于均方误差（MSE）。PSNR大于30dB通常认为质量不错，大于40dB则非常优秀。但其对感知质量的评价有时与人类视觉不一致。
- 结构相似性指数（SSIM）：从亮度、对比度、结构三个方面衡量两幅图像的相似性，取值范围[-1, 1]，值越接近1越好。SSIM比PSNR更符合人眼的主观感受。
在Python中，可以使用skimage.metrics库方便地计算：
from skimage.metrics import peak_signal_noise_ratio as psnr from skimage.metrics import structural_similarity as ssim import cv2 pred_img = cv2.imread('dehazed_result.jpg') gt_img = cv2.imread('ground_truth_clear.jpg') psnr_value = psnr(gt_img, pred_img) ssim_value = ssim(gt_img, pred_img, multichannel=True, channel_axis=2) # 对于彩色图像 print(f"PSNR: {psnr_value:.2f} dB, SSIM: {ssim_value:.4f}")在测试集上计算所有图像对的平均PSNR和SSIM，就可以定量比较不同模型或不同参数的优劣。
5.3 主观效果分析与常见问题
将去雾结果、原始有雾图和真实清晰图放在一起对比观察：
- 去雾是否彻底：远景的雾气是否被有效移除？近景的物体边缘是否清晰？
- 细节与纹理保持：物体的纹理（如树叶、砖墙）是否得以保留，还是被过度平滑了？
- 颜色保真度：去雾后的图像颜色是否自然？有没有出现整体色偏（如发蓝、发黄）？
- 伪影与失真：图像中是否出现了原本不存在的奇怪纹路、光晕或块状伪影？天空区域是否出现了不自然的颜色过渡？
对偶GAN模型通常能在去雾彻底性和细节保持上取得不错的平衡。但你可能还是会发现一些问题：
- 对于极端浓雾：模型可能去雾不完全，或者为了去雾而过度增强对比度，导致暗部细节丢失。
- 天空区域处理：天空本身没有纹理，模型可能错误地“创造”出一些云彩纹理，或者出现颜色断层。
- 运动模糊与雾的混淆：如果数据集中包含运动模糊的图像，模型可能无法区分，导致错误处理。
这些问题往往需要通过改进数据集质量（清洗有问题的样本）、设计更精细的损失函数（例如增加感知损失、风格损失）或使用更强大的网络架构（如引入注意力机制）来解决。
6. 项目扩展与进阶思考
拿到一个能跑通的模型只是起点。如何让它更好、更快、更实用，才是进阶之路。
6.1 模型轻量化与部署
训练好的PyTorch模型（.pth文件）通常比较大（几十到几百MB），且依赖PyTorch环境运行，不适合直接部署到移动端或嵌入式设备。可以考虑以下方案：
- 模型剪枝与量化：使用PyTorch提供的工具，对训练好的模型进行剪枝（移除不重要的权重连接）和量化（将FP32权重转换为INT8），可以显著减小模型体积并提升推理速度，同时精度损失可控。
- 模型转换：将PyTorch模型转换为其他更高效的推理框架格式。
- TorchScript：PyTorch自带的序列化格式，可以脱离Python环境运行，适合服务端部署。
- ONNX：开放的模型交换格式。可以将PyTorch模型导出为
.onnx文件，然后使用ONNX Runtime、TensorRT等高性能推理引擎进行部署，尤其在GPU上能获得极大加速。 - Core ML / TFLite：分别用于苹果iOS和安卓移动端的部署。
一个简单的ONNX导出示例：
import torch dummy_input = torch.randn(1, 3, 256, 256).to(device) # 与模型输入尺寸一致 torch.onnx.export(G, dummy_input, "dehaze_dualgan.onnx", input_names=['input'], output_names=['output'], dynamic_axes={'input': {0: 'batch_size'}, 'output': {0: 'batch_size'}})6.2 尝试改进网络结构
如果对现有效果不满意，可以尝试学术界最新的网络架构改进：
- 注意力机制：在U-Net的跳跃连接或瓶颈层加入通道注意力（如SE Block）或空间注意力，让模型更关注有雾的区域和重要的细节。
- 多尺度处理：使用图像金字塔或空洞卷积（Dilated Convolution）来融合不同尺度的特征，有助于同时处理近景和远景的雾气。
- 物理模型引导：将传统的大气散射模型与深度学习结合。例如，让网络同时估计透射率图（Transmission Map）和大气光（Atmospheric Light），然后根据物理公式复原图像。这种“白盒”方法可解释性更强，有时效果更好。
6.3 处理真实世界无配对数据
本项目假设你有成对的（有雾，清晰）数据。但现实中，大量数据是不成对的。这时，你可以考虑将本项目升级为CycleGAN风格。CycleGAN也是基于循环一致性，但它不要求数据严格配对，只需要两个域的图像集合（一堆有雾图，一堆清晰图）。你需要修改数据加载部分，并可能调整损失函数（例如增加身份损失的重要性）。这是一个非常有价值的扩展方向。
最后，我想说的是，这个项目提供了一个绝佳的深度学习图像去雾实践平台。从环境配置、代码理解、模型训练到调参优化、问题排查，完整走一遍这个流程，你对GAN、对图像翻译任务、乃至对深度学习的工程实践，都会有质的飞跃。模型训练的过程可能枯燥，可能会遇到各种莫名其妙的错误，但每一次解决问题的过程，都是宝贵的经验积累。不妨在跑通基础版本后，大胆地去修改网络结构、调整损失函数、尝试新的数据增强策略，看看会发生什么。这才是做项目的乐趣所在。
本文还有配套的精品资源，点击获取
