企业官网建设流程全解析

简介：本资源是一套基于Vision Transformer（ViT）的图像去雾算法完整实现方案，面向计算机视觉方向的研究者、深度学习开发者及高校高年级本科生，解决雾霾天气下图像对比度低、细节模糊等实际成像问题。压缩包共340个文件，包含204个Python源码文件（含模型定义、训练/测试主逻辑、数据预处理模块）、39张效果对比图与可视化结果（png/gif）、16个配置文件（yaml）、12个实验指标CSV记录、9个Jupyter Notebook演示案例及9个说明文档（txt/md），整体大小为156.38MB，结构清晰，支持开箱即用与二次训练。已有1442人学习下载，提供完整的项目介绍与使用说明文档、预训练权重加载路径配置（My_best_model目录）、option.py参数详解（如--train_ps补丁尺寸设置），并附带多组CIFAR-10/100上的ViT与ResNet损失曲面分析数据，便于理解模型优化行为与泛化特性。

1. Vision Transformer 不是只能做分类——它正在改写图像去雾的底层逻辑

很多人第一次听说 Vision Transformer（ViT）时，脑海里浮现的是 ImageNet 分类排行榜上的 SOTA 数字，或是 ViT-B/16 在下游任务微调时那几行from transformers import ViTModel。但如果你正被雾霾图像困扰——监控摄像头拍出灰蒙蒙的车牌、无人机航拍因大气散射丢失纹理细节、医疗内窥镜图像因介质浑浊导致边界模糊——那么 ViT 的价值远不止于“换掉 ResNet”。它用全局注意力机制建模长程依赖，天然适配去雾任务中「雾浓度空间非均匀、透射率与场景深度强耦合」这一核心难点。本项目不是简单套用 ViT 主干提取特征，而是将 ViT 的 patch embedding、自注意力权重、cls token 动态响应，全部纳入物理模型约束框架：把大气散射方程 $ I(x) = J(x)t(x) + A(1-t(x)) $ 中的透射率 $ t(x) $ 和全局大气光 $ A $，分别由 ViT 的多层注意力图与 cls token 回归联合预测。适合已有 Python 基础、熟悉 PyTorch 图像处理流程、且需要在真实监控/遥感/车载场景中部署轻量级去雾模块的工程师。

2. 为什么必须用 Vision Transformer 而非 CNN 做去雾主干？

2.1 CNN 在去雾任务中的结构性瓶颈

传统基于 CNN 的去雾方法（如 AOD-Net、GFN、DehazeNet）普遍采用 U-Net 或编解码结构，其卷积核感受野受限于固定尺寸（如 3×3、5×5），即使堆叠多层也难以建模跨区域的雾浓度关联。例如，在一张含远山与近树的图像中，山顶雾浓而山脚雾淡，CNN 需要数十层才能让山顶特征影响山脚的透射率估计，导致梯度弥散和伪影。更关键的是，CNN 的局部归纳偏置（local inductive bias）与雾的物理分布矛盾：雾是全局光学现象，其散射强度由整幅图像的大气条件决定，而非像素邻域统计。

提示：实测对比显示，在 RESIDE-SOTS 测试集上，ResNet-50 主干的 DehazeNet 在远距离物体 PSNR 下降达 4.2 dB，而同等参数量的 ViT-Tiny 主干模型保持稳定——这印证了全局建模的必要性。

2.2 ViT 如何从物理层面重构去雾流程

Vision Transformer 的核心突破在于将图像切分为不重叠 patch（如 16×16），每个 patch 经线性投影后成为 token 序列。自注意力机制使每个 token 可以直接加权聚合所有其他 token 的信息，天然支持「远距离雾浓度一致性约束」。本项目具体实现中：

• Patch Embedding 层：输入图像 $ I \in \mathbb{R}^{H \times W \times 3} $ 被划分为 $ N = (H/16) \times (W/16) $ 个 patch，每个 patch 线性映射为 768 维向量（ViT-Base 配置），形成 $ X \in \mathbb{R}^{N \times 768} $；
• Position Embedding 注入：添加可学习的位置编码 $ E_{pos} \in \mathbb{R}^{N \times 768} $，保留空间先验，避免纯注意力丢失结构；
• CLS Token 动态回归：在序列前端插入 [CLS] token，其最终输出经两层 MLP 直接回归全局大气光 $ A $，维度为 3（RGB）；

# vision_transformer_dehaze.py 片段：CLS token 大气光回归 class CLSAtrousRegressor(nn.Module): def __init__(self, embed_dim=768, hidden_dim=512): super().__init__() self.mlp = nn.Sequential( nn.Linear(embed_dim, hidden_dim), nn.GELU(), nn.Dropout(0.1), nn.Linear(hidden_dim, 3) # 输出 R/G/B 三通道大气光值 ) def forward(self, x_cls): # x_cls: [B, 1, 768] return torch.sigmoid(self.mlp(x_cls)) * 1.0 # 限制 A ∈ [0, 1]

该代码中torch.sigmoid确保输出在 [0,1] 区间，符合归一化图像的物理范围；* 1.0是显式类型对齐，避免混合精度训练时的梯度异常。

2.3 注意力图作为透射率先验的可行性验证

ViT 每层的注意力权重矩阵 $ \text{Attention}(Q,K,V) \in \mathbb{R}^{N \times N} $，其第 $ i $ 行表示第 $ i $ 个 patch 对所有 patch 的关注强度。实验发现：在深层（如第 10 层），高雾区域 patch 的注意力分布更集中于自身（自注意力权重 >0.7），而低雾区域则呈现广泛分散模式。这与透射率 $ t(x) $ 的物理定义高度吻合——$ t(x) $ 越小（雾越浓），光线衰减越强，局部信息越主导。因此，本项目将第 10 层注意力图的熵值 $ H_i = -\sum_j \alpha_{ij} \log \alpha_{ij} $ 作为空间变化透射率的初始先验，输入后续轻量 CNN 解码头进行精细化校正。

3. 从零复现：Python 环境搭建、数据加载与模型训练全流程

3.1 Python 环境配置与依赖安装（兼容 Windows/Linux/macOS）

本项目严格限定 Python 3.9+，因 PyTorch 2.0+ 对torch.compile的支持需此版本。避免使用conda install pytorch默认渠道（可能拉取 CPU-only 版本），必须指定 CUDA 构建版本：

# 创建隔离环境（推荐） python -m venv vit_dehaze_env source vit_dehaze_env/bin/activate # Linux/macOS # vit_dehaze_env\Scripts\activate.bat # Windows # 安装 PyTorch（以 CUDA 11.8 为例，根据 nvidia-smi 输出选择） pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118 # 安装核心依赖（注意 cv2 必须从 conda-forge 安装以避免 ABI 冲突） pip install numpy==1.23.5 # 避免 1.24+ 与旧版 PIL 兼容问题 pip install opencv-python-headless==4.8.1.78 # headless 版本避免 GUI 依赖 pip install timm==0.9.2 # 提供 ViT 预训练权重与灵活 backbone 接口 pip install albumentations==1.3.1 # 高性能图像增强，支持多进程

注意：若执行import cv2报错libglib-2.0.so.0: cannot open shared object file（Linux），需运行sudo apt-get install libglib2.0-0；Windows 用户若遇cv2DLL 加载失败，请卸载所有opencv-python相关包后重装opencv-python-headless。

3.2 数据集组织与 RESIDE 格式兼容加载器

本项目默认使用 RESIDE 数据集（Realistic Single Image Dehazing），其 SOTS（Synthetic Objective Testing Set）子集提供成对清晰/有雾图像。目录结构必须严格如下：

data/ ├── train/ │ ├── haze/ # 训练雾图，命名如 1_haze.png, 2_haze.png │ └── clear/ # 对应清晰图，命名如 1_clear.png, 2_clear.png ├── test_sots/ │ ├── haze/ │ └── clear/

加载器采用内存映射优化，避免训练时 IO 瓶颈：

# data_loader.py import torch from torch.utils.data import Dataset, DataLoader from PIL import Image import numpy as np import os class RESIDEDataset(Dataset): def __init__(self, root_dir, mode='train', transform=None): self.root_dir = root_dir self.mode = mode self.transform = transform # 自动匹配 haze/clear 文件名（忽略后缀差异） self.haze_files = sorted([f for f in os.listdir(f"{root_dir}/{mode}/haze") if f.endswith(('.png', '.jpg'))]) self.clear_files = [f.replace('_haze', '_clear').replace('haze', 'clear') for f in self.haze_files] def __len__(self): return len(self.haze_files) def __getitem__(self, idx): haze_path = os.path.join(self.root_dir, self.mode, 'haze', self.haze_files[idx]) clear_path = os.path.join(self.root_dir, self.mode, 'clear', self.clear_files[idx]) haze_img = np.array(Image.open(haze_path).convert('RGB')) / 255.0 clear_img = np.array(Image.open(clear_path).convert('RGB')) / 255.0 if self.transform: augmented = self.transform(image=haze_img, image0=clear_img) # image0 为清晰图别名 haze_img, clear_img = augmented['image'], augmented['image0'] # 转为 tensor 并调整维度 [C, H, W] haze_tensor = torch.from_numpy(haze_img).permute(2, 0, 1).float() clear_tensor = torch.from_numpy(clear_img).permute(2, 0, 1).float() return haze_tensor, clear_tensor # 实例化训练集（含增强） train_dataset = RESIDEDataset( root_dir="data", mode="train", transform=albumentations.Compose([ albumentations.RandomCrop(height=256, width=256, p=0.8), albumentations.HorizontalFlip(p=0.5), albumentations.RandomBrightnessContrast(p=0.2), albumentations.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) # ImageNet 标准化 ]) )

关键点说明：albumentations.Normalize使用 ImageNet 均值标准差，确保 ViT 预训练权重迁移有效；RandomCrop尺寸设为 256×256，因 ViT-Base 的 patch size=16，故输入需为 16 的整数倍（256/16=16），保证 patch 划分无余数。

3.3 模型训练命令与超参数配置表

训练脚本train.py支持单卡/多卡 DDP，核心启动命令如下：

# 单卡训练（最常用） python train.py \ --data_dir data \ --model_name vit_base_patch16_224 \ --batch_size 8 \ --lr 1e-4 \ --epochs 100 \ --save_freq 10 \ --log_dir logs/vit_dehaze_base # 多卡训练（需 NCCL 后端） python -m torch.distributed.launch --nproc_per_node=2 train.py \ --data_dir data \ --model_name vit_small_patch16_224 \ --batch_size 16 \ --lr 2e-4 \ --epochs 80

下表为不同 ViT 变体在 RTX 4090 上的实测超参建议（基于 RESIDE-SOTS 验证集 PSNR 收敛性）：

提示：若显存不足，可将--batch_size减半，并用--gradient_accumulation_steps 2补偿等效 batch size，避免梯度更新不稳定。

4. 关键模块解析：透射率解码头设计与物理损失函数组合

4.1 透射率解码头：从注意力熵到精细化 $ t(x) $

ViT 主干输出的注意力熵仅提供粗粒度先验，需轻量 CNN 解码头进行空间细化。本项目采用三阶段结构：

1. 熵图上采样：将第 10 层注意力图熵值 $ H \in \mathbb{R}^{16 \times 16} $ 双线性插值至 $ 256 \times 256 $；
2. 多尺度特征融合：ViT 最后一层 patch embedding $ X_{last} \in \mathbb{R}^{256 \times 768} $ 重塑为 $ 16 \times 16 \times 768 $，经 1×1 卷积压缩通道至 64，再上采样至 256×256；
3. 残差精修：将熵图与上采样特征拼接，输入 3 层卷积（kernel=3, padding=1），每层后接 LeakyReLU，最后一层输出单通道 $ \hat{t}(x) $。

# decoder.py class TransmissionDecoder(nn.Module): def __init__(self, embed_dim=768, upsample_scale=16): super().__init__() self.entropy_proj = nn.Conv2d(1, 64, 1) # 熵图通道扩展 self.feature_proj = nn.Conv2d(embed_dim, 64, 1) # ViT 特征压缩 self.refine_net = nn.Sequential( nn.Conv2d(128, 64, 3, padding=1), nn.LeakyReLU(0.2), nn.Conv2d(64, 32, 3, padding=1), nn.LeakyReLU(0.2), nn.Conv2d(32, 1, 3, padding=1), # 输出单通道 t(x) nn.Sigmoid() # 保证 t ∈ [0,1] ) def forward(self, attn_entropy, vit_features): # attn_entropy: [B, 1, 16, 16] -> [B, 1, 256, 256] entropy_up = F.interpolate(attn_entropy, scale_factor=16, mode='bilinear') entropy_feat = self.entropy_proj(entropy_up) # [B, 64, 256, 256] # vit_features: [B, 256, 768] -> [B, 768, 16, 16] -> [B, 64, 256, 256] B, N, C = vit_features.shape feat_2d = vit_features.transpose(1, 2).view(B, C, 16, 16) feat_up = F.interpolate(feat_2d, scale_factor=16, mode='bilinear') feat_proj = self.feature_proj(feat_up) fused = torch.cat([entropy_feat, feat_proj], dim=1) # [B, 128, 256, 256] return self.refine_net(fused) # [B, 1, 256, 256]

F.interpolate使用bilinear模式而非nearest，因双线性插值能保留熵图的空间渐变特性，避免块状伪影。

4.2 物理驱动的复合损失函数设计

单纯 L1/L2 损失易导致去雾后图像过饱和或色彩失真。本项目采用四重损失组合：

# loss.py def physical_loss(haze, pred_j, pred_t, pred_a): # haze: [B,3,H,W], pred_j/t: [B,3,H,W]/[B,1,H,W], pred_a: [B,3] pred_a_exp = pred_a.unsqueeze(-1).unsqueeze(-1) # [B,3,1,1] recon = pred_j * pred_t + pred_a_exp * (1 - pred_t) # [B,3,H,W] return F.l1_loss(recon, haze) def tv_loss(pred_t): # pred_t: [B,1,H,W] h_tv = torch.pow(pred_t[:, :, 1:, :] - pred_t[:, :, :-1, :], 2).mean() w_tv = torch.pow(pred_t[:, :, :, 1:] - pred_t[:, :, :, :-1], 2).mean() return h_tv + w_tv # 训练循环中调用 loss_rec = F.l1_loss(pred_j, clear) loss_phys = physical_loss(haze, pred_j, pred_t, pred_a) loss_tv = tv_loss(pred_t) loss_a = F.mse_loss(pred_a, haze.mean(dim=[2,3])) # 粗略初始化 A total_loss = loss_rec + 0.8 * loss_phys + 0.01 * loss_tv + 0.5 * loss_a

haze.mean(dim=[2,3])作为 $ A $ 的粗略估计，用于监督 $ \mathcal{L}_A $，比单纯随机初始化收敛更快。

5. 部署与推理：单张图像去雾、批量处理及性能调优技巧

5.1 单张图像快速去雾脚本（支持 JPG/PNG）

infer.py提供开箱即用的推理接口，自动处理任意尺寸图像（通过 padding 适配 ViT 输入要求）：

python infer.py \ --model_path logs/vit_dehaze_base/best_model.pth \ --input_image data/test_sots/haze/1_haze.png \ --output_image results/1_dehazed.png \ --device cuda:0

核心逻辑在于动态 padding：ViT 要求输入为 16 的整数倍，故对原始尺寸 $ H \times W $，计算 $ H' = \lceil H/16 \rceil \times 16 $，$ W' = \lceil W/16 \rceil \times 16 $，用 reflection padding 避免边缘黑边：

# infer.py 片段 def pad_to_vit_size(img_tensor): # img_tensor: [C, H, W] _, h, w = img_tensor.shape new_h = ((h - 1) // 16 + 1) * 16 new_w = ((w - 1) // 16 + 1) * 16 pad_h = new_h - h pad_w = new_w - w # reflection padding：镜像填充，比 zero-padding 更自然 return F.pad(img_tensor, (0, pad_w, 0, pad_h), mode='reflect') # 推理时 orig_h, orig_w = haze_pil.size[::-1] # PIL size is (W,H) haze_tensor = transforms.ToTensor()(haze_pil).unsqueeze(0) # [1,C,H,W] haze_padded = pad_to_vit_size(haze_tensor[0]).unsqueeze(0) # [1,C,H',W'] with torch.no_grad(): pred_j = model(haze_padded.to(device)) # 去除 padding pred_j_cropped = pred_j[:, :, :orig_h, :orig_w]

F.pad(..., mode='reflect')是关键：reflection padding 将图像边缘像素对称复制，避免 zero-padding 引入的虚假暗角，实测 PSNR 提升 0.9 dB。

5.2 批量处理与 FPS 优化技巧

对监控视频流或大批量图像，需启用torch.compile（PyTorch 2.0+）和 FP16 推理：

# infer_batch.py model = torch.compile(model) # 图形级优化，首次运行稍慢，后续加速 1.8x model = model.half().to(device) # FP16 推理 haze_batch = haze_batch.half().to(device) with torch.no_grad(), torch.autocast(device_type='cuda'): pred_batch = model(haze_batch)

在 RTX 4090 上，ViT-Small 批处理（batch_size=16, 512×512）实测吞吐达42 FPS，较未编译版本提升 83%。若需进一步提速，可关闭torch.compile的dynamic=True（默认开启），改用静态 shape 编译：

# 针对固定尺寸（如 512×512）的极致优化 model = torch.compile(model, dynamic=False, fullgraph=True)

此时编译后首次推理耗时增加约 200ms，但后续帧稳定在 18ms/帧（55 FPS）。

5.3 模型轻量化：知识蒸馏压缩 ViT-Base 至 ViT-Tiny

生产环境常需在 Jetson Orin 或树莓派上部署，此时 ViT-Base 过重。本项目提供蒸馏脚本distill.py，用 ViT-Base 作为教师模型指导 ViT-Tiny 训练：

python distill.py \ --teacher_path logs/vit_dehaze_base/best_model.pth \ --student_arch vit_tiny_patch16_224 \ --distill_weight 0.7 \ --temperature 4.0

蒸馏损失包含两部分：

• 特征蒸馏：学生 ViT-Tiny 最后一层 patch embedding 与教师对应层的 MSE 损失（权重 0.3）；
• 输出蒸馏：学生去雾图 $ \hat{J}_s $ 与教师 $ \hat{J}_t $ 的 KL 散度（温度缩放后，权重 0.7）；

温度 $ T=4.0 $ 使软标签分布更平滑，提升小模型学习效率。蒸馏后 ViT-Tiny 在 SOTS 上 PSNR 仅下降 0.6 dB（24.2 → 23.6），但参数量从 86M 降至 5.7M，推理速度提升 4.2 倍。

提示：若蒸馏过程出现 NaN 损失，立即降低--temperature至 2.0，并检查教师模型是否在 eval 模式下运行（model.eval()）。

本文还有配套的精品资源，点击获取