【GAN 系列·第十一篇】GAN 在工业界的应用：超分辨率、人脸合成与数据增强

拾-光

268人浏览 · 2026-06-06 00:41:27

拾-光 · 2026-06-06 00:41:27 发布

【GAN 系列·第十一篇】GAN 在工业界的应用：超分辨率、人脸合成与数据增强

作者：技术博主 | 更新时间：2026-05-24 | 阅读时长：约 23 分钟
系列：GAN 从入门到精通（共 12 篇）
环境：Python 3.12，PyTorch 2.x，torchvision
标签：超分辨率 ESRGAN Real-ESRGAN 数据增强 人脸合成 Deepfake检测 工业GAN 应用

在这里插入图片描述

🔥 本篇目标：前十篇讲了 GAN 的理论和架构，本篇把视角切换到工业落地。超分辨率是 GAN 最成功的商业应用之一，从 Adobe Photoshop 的"超级分辨率"到手机摄像头的夜景增强，背后都有 GAN 的影子。本篇深入四个核心工业应用：超分辨率（SRGAN/ESRGAN/Real-ESRGAN）、人脸合成与换脸（DeepFake 的技术原理与检测）、医疗影像增强（数据稀缺场景的 GAN 方案）、数据增强（如何用 GAN 解决训练数据不足的问题）。每个应用都给出核心技术和可运行代码框架。

系列进度

篇次	主题	状态
第一篇～第十篇	GAN基础→三大范式对比	✅
第十一篇（本篇）	工业界应用：超分、合成、增强	—
第十二篇	收官：GAN 的前沿与未来	即将发布

一、超分辨率：SRGAN 到 Real-ESRGAN
二、感知损失：让超分结果更逼真
三、Real-ESRGAN：处理真实世界的退化
四、人脸合成与 DeepFake 检测
五、医疗影像：数据稀缺场景的 GAN 方案
六、数据增强：用 GAN 扩充训练集
七、代码实战：超分辨率 Pipeline
八、工业部署的工程挑战

一、超分辨率：SRGAN 到 Real-ESRGAN

import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
import warnings
warnings.filterwarnings('ignore')

print("超分辨率（Super-Resolution）：GAN 最成功的商业应用")
print()
print("  什么是超分辨率？")
print("  低分辨率图像（LR）→ 高分辨率图像（HR）")
print("  如：64×64 → 256×256（4× 放大）")
print()
print("  为什么超分是典型的病态问题？")
print("  一张 LR 图像对应无数可能的 HR 图像（欠定方程组）")
print("  MSE 最优解 = 所有可能 HR 的平均值 = 模糊！")
print()

sr_methods_history = [
    ("双线性插值",       "传统",  "极快",    "差（锯齿）",      "无学习，直接插值"),
    ("双三次插值",       "传统",  "快",      "一般",            "更平滑，仍然模糊"),
    ("SRCNN（2014）",   "深度学习","快",     "较好",            "首个 CNN 超分"),
    ("VDSR（2016）",    "深度学习","快",     "好",              "更深的残差网络"),
    ("SRGAN（2016）",   "GAN",   "中",      "很好（感知）",     "引入感知损失+GAN"),
    ("ESRGAN（2018）",  "GAN",   "中",      "极好",            "RRDB + 无 BN"),
    ("Real-ESRGAN（2021）","GAN","中",     "极好（真实退化）", "复合退化模型"),
    ("StableSR（2023）","扩散+SR","慢",    "最好（细节丰富）", "扩散模型加入SR"),
]

print(f"  {'方法':^20} {'类型':^10} {'速度':^6} {'质量':^16} {'核心创新':^24}")
print("  " + "─" * 80)
for method, mtype, speed, quality, innovation in sr_methods_history:
    print(f"  {method:^20} {mtype:^10} {speed:^6} {quality:^16} {innovation:^24}")

print()
print("  商业应用案例：")
commercial = [
    ("Adobe Photoshop",    "Super Resolution（4×，基于 Lightroom）"),
    ("Apple iPhone",       "PhotoML（夜景模式的超分后处理）"),
    ("NVIDIA DLSS",        "游戏实时超分（AI 渲染，低分辨率→高分）"),
    ("AMD FSR",            "开源超分，FidelityFX Super Resolution"),
    ("腾讯智影",           "老照片修复（超分 + 上色 + 去噪）"),
    ("美颜相机/ArcSoft",   "人脸超分（4×，实时移动端）"),
]
print(f"  {'产品':^20} {'超分应用':^42}")
print("  " + "─" * 66)
for product, app in commercial:
    print(f"  {product:^20} {app:^42}")

二、感知损失：让超分结果更逼真

print("\n感知损失（Perceptual Loss）：SRGAN 的核心创新")
print()
print("  问题：MSE 损失的超分结果")
print("  min E[||HR - SR||²]")
print("  → 所有可能 HR 的均值 → 模糊（平均多个锐利纹理 = 平滑）")
print()
print("  感知损失的解决思路（Johnson et al., 2016）：")
print("  不在像素空间比较，而在特征空间比较")
print()
print("  L_perceptual = ||φ(SR) - φ(HR)||²")
print("  其中 φ() = VGG 网络的某一层特征（如 relu3_4）")
print()
print("  VGG 特征为什么有感知意义？")
print("  浅层：边缘、颜色（像素级细节）")
print("  中层：纹理、图案（感知质量的核心）")
print("  深层：语义（物体类别信息）")
print()
print("  超分辨率最常用 VGG relu2_2 或 relu3_4")
print("  → 强迫超分结果在'中层纹理特征'上与真实图像一致")
print()

import torch
import torch.nn as nn
import torchvision.models as models

class VGGPerceptualLoss(nn.Module):
    """
    基于 VGG19 的感知损失
    使用 relu3_4 层特征（SRGAN/ESRGAN 的标准选择）
    """

    def __init__(self, feature_layer: int = 34,
                 use_input_norm: bool = True):
        """
        feature_layer: VGG19 的层索引
        34 = relu3_4（第 3 个 conv block 的第 4 个 relu）
        """
        super().__init__()

        vgg = models.vgg19(pretrained=False)
        self.features = nn.Sequential(
            *list(vgg.features.children())[:feature_layer + 1]
        )

        # 冻结 VGG 参数（不参与训练）
        for param in self.features.parameters():
            param.requires_grad = False

        # ImageNet 归一化（VGG 的输入要求）
        if use_input_norm:
            self.register_buffer(
                'mean',
                torch.tensor([0.485, 0.456, 0.406]).view(1, 3, 1, 1)
            )
            self.register_buffer(
                'std',
                torch.tensor([0.229, 0.224, 0.225]).view(1, 3, 1, 1)
            )
        self.use_input_norm = use_input_norm

    def forward(self, sr: torch.Tensor,
                hr: torch.Tensor) -> torch.Tensor:
        """
        sr: 超分辨率图像 (B, 3, H, W)，值域 [0, 1]
        hr: 真实高分辨率图像 (B, 3, H, W)，值域 [0, 1]
        """
        if self.use_input_norm:
            sr = (sr - self.mean) / self.std
            hr = (hr - self.mean) / self.std

        sr_feat = self.features(sr)
        hr_feat = self.features(hr)

        return F.l1_loss(sr_feat, hr_feat)   # L1 比 L2 更鲁棒


# 验证感知损失
torch.manual_seed(42)
perc_loss = VGGPerceptualLoss(feature_layer=34)

sr_img = torch.rand(2, 3, 64, 64)   # 模拟 SR 输出
hr_img = torch.rand(2, 3, 64, 64)   # 模拟真实 HR

with torch.no_grad():
    loss_perc  = perc_loss(sr_img, hr_img)
    loss_pixel = F.l1_loss(sr_img, hr_img)

print(f"  感知损失验证：")
print(f"  像素 L1 损失：  {loss_pixel.item():.6f}")
print(f"  感知 L1 损失：  {loss_perc.item():.6f}")
print()
print("  SRGAN 的总损失：")
print("  L_total = L_content + λ_adv × L_adv")
print("  L_content = 0.006 × VGG 感知损失（relu3_4）+ 1e-2 × 像素 MSE")
print("  L_adv     = -log D(G(LR))（非饱和 GAN 损失）")
print()
print("  为什么感知损失这么小（0.006）？")
print("  VGG 特征的数值范围远大于像素（不同量级），")
print("  0.006 是为了让感知损失和像素损失在同一量级上贡献")

三、Real-ESRGAN：处理真实世界的退化

print("\nReal-ESRGAN（2021）：面向真实世界退化的超分辨率")
print()
print("  SRGAN/ESRGAN 的问题：")
print("  训练数据：HR 图像用双三次下采样得到 LR（理想退化）")
print("  真实世界：LR 图像经历噪声、压缩、模糊、过曝等（复合退化）")
print("  结果：ESRGAN 对'理想退化'效果好，对真实图像效果差")
print()
print("  Real-ESRGAN 的解决：高阶退化模型")
print()
print("  退化流程（对 HR 图像依次施加）：")

degradation_pipeline = [
    ("模糊（Blur）",
     "高斯模糊、运动模糊、散焦模糊（随机选一种）",
     "模拟相机失焦、运动模糊"),
    ("下采样（Resize）",
     "随机选择：区域/双线性/双三次/朗佐斯 + 随机比例",
     "模拟不同分辨率传感器"),
    ("噪声（Noise）",
     "高斯噪声、泊松噪声、JPEG 噪声",
     "模拟传感器噪声和压缩噪声"),
    ("JPEG 压缩",
     "随机 JPEG 质量（30-95）",
     "模拟网络传输的压缩损失"),
    ("重复退化",
     "以上步骤重复 1-2 次（高阶退化）",
     "真实图像通常经历多次退化"),
]

print(f"  {'退化步骤':^18} {'具体操作':^36} {'模拟的真实场景':^24}")
print("  " + "─" * 82)
for step, operation, scene in degradation_pipeline:
    print(f"  {step:^18} {operation:^36} {scene:^24}")

print()
print("  Real-ESRGAN 的架构改进（相比 ESRGAN）：")
print()
arch_improvements = [
    ("生成器 RRDB-Net", "更大的 RRDB 网络（23个RRDB块），保持无 BN"),
    ("U-Net 判别器",    "替换了 ESRGAN 的 VGG 判别器，更好地感知细节"),
    ("光谱归一化",      "判别器使用谱归一化，训练更稳定"),
    ("训练策略",        "第一阶段 L1 预训练，第二阶段 GAN 微调"),
]
for arch, desc in arch_improvements:
    print(f"  ✅ [{arch}]：{desc}")

print()

class RRDBBlock(nn.Module):
    """
    ESRGAN/Real-ESRGAN 的核心模块：残差密集块（RRDB）
    比 SRGAN 的 ResBlock 更强，无 BatchNorm
    """

    def __init__(self, channels: int = 64, growth_channels: int = 32):
        super().__init__()
        # 残差密集连接
        self.dense = nn.ModuleList([
            nn.Sequential(
                nn.Conv2d(channels + i*growth_channels,
                          growth_channels, 3, 1, 1),
                nn.LeakyReLU(0.2, True)
            )
            for i in range(4)
        ])
        self.final = nn.Conv2d(channels + 4*growth_channels,
                               channels, 3, 1, 1)
        self.scale  = 0.2   # 残差缩放（防止梯度爆炸）

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        feat = [x]
        for layer in self.dense:
            new_feat = layer(torch.cat(feat, dim=1))
            feat.append(new_feat)
        out = self.final(torch.cat(feat, dim=1))
        return x + self.scale * out   # 残差连接


class ESRGANGenerator(nn.Module):
    """
    ESRGAN/Real-ESRGAN 生成器
    输入 LR 图像，输出 HR 图像（4× 放大）
    """

    def __init__(self, in_channels: int = 3,
                 n_rrdb: int = 6,        # 原论文用 23，这里用 6 演示
                 channels: int = 64,
                 scale: int = 4):
        super().__init__()

        self.scale = scale

        # 浅层特征提取
        self.head  = nn.Conv2d(in_channels, channels, 3, 1, 1)

        # RRDB 主体
        self.rrdb  = nn.Sequential(*[RRDBBlock(channels) for _ in range(n_rrdb)])

        # 尾部卷积
        self.tail  = nn.Conv2d(channels, channels, 3, 1, 1)

        # 上采样（PixelShuffle 或 最近邻+卷积）
        n_up       = int(np.log2(scale))   # 4× = 2次 2×
        up_layers  = []
        for _ in range(n_up):
            up_layers += [
                nn.Conv2d(channels, channels * 4, 3, 1, 1),
                nn.PixelShuffle(2),     # 把通道折叠到空间维度（2×放大）
                nn.LeakyReLU(0.2, True),
            ]
        self.upsample = nn.Sequential(*up_layers)

        # 输出层
        self.output = nn.Sequential(
            nn.Conv2d(channels, channels, 3, 1, 1),
            nn.LeakyReLU(0.2, True),
            nn.Conv2d(channels, out_channels=3, kernel_size=3, padding=1),
        )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        feat  = self.head(x)
        body  = self.tail(self.rrdb(feat))
        feat  = feat + body         # 全局残差连接
        feat  = self.upsample(feat)
        return self.output(feat)


# 验证
torch.manual_seed(42)
G_sr = ESRGANGenerator(n_rrdb=4, channels=32, scale=4)   # 小版本演示

lr_img = torch.rand(1, 3, 32, 32)   # 低分辨率输入
with torch.no_grad():
    hr_pred = G_sr(lr_img)

print(f"  ESRGAN 生成器验证：")
print(f"  LR 输入: {tuple(lr_img.shape)}")
print(f"  HR 输出: {tuple(hr_pred.shape)}（4× 放大 ✓）")
n_params = sum(p.numel() for p in G_sr.parameters())
print(f"  参数量: {n_params:,}（真实 ESRGAN 约 16M）")

四、人脸合成与 DeepFake 检测

print("\n人脸合成与 DeepFake 技术")
print()
print("  DeepFake 技术栈（主要 GAN 方法）：")
print()

deepfake_methods = [
    {
        "name":    "人脸替换（Face Swap）",
        "model":   "Encoder-Decoder + AdaIN",
        "method":  "把源人脸的身份特征注入到目标帧的姿态/表情中",
        "example": "FaceSwap、DeepFaceLab",
        "risk":    "最常见的 DeepFake 形式",
    },
    {
        "name":    "人脸重演（Face Reenactment）",
        "model":   "基于关键点的 GAN（First Order Motion）",
        "method":  "用源视频的动作驱动目标人脸的表情和姿态",
        "example": "Face2Face、First Order Model",
        "risk":    "可以让任意人'说任意话'",
    },
    {
        "name":    "属性编辑（Attribute Editing）",
        "model":   "StyleGAN + Latent Direction",
        "method":  "在 w 空间中沿特定方向移动，改变年龄/发色/性别",
        "example": "StarGAN、InterFaceGAN",
        "risk":    "年龄、性别等属性可被任意修改",
    },
    {
        "name":    "完全合成（Synthetic Face）",
        "model":   "StyleGAN v2/v3",
        "method":  "从随机噪声生成完全不存在的人脸",
        "example": "thispersondoesnotexist.com",
        "risk":    "虚假身份创建",
    },
]

for m in deepfake_methods:
    print(f"  ─── [{m['name']}] ───")
    print(f"  使用模型：{m['model']}")
    print(f"  技术原理：{m['method']}")
    print(f"  代表工具：{m['example']}")
    print(f"  潜在风险：{m['risk']}")
    print()

print("  DeepFake 检测的主要方法：")
print()

detection_methods = [
    ("频域分析",
     "GAN 生成图像在频率域中有独特的伪影（高频分量异常）",
     "频谱分析、DCT 特征",
     "对新型 GAN 泛化性差"),
    ("生物特征一致性",
     "检测眨眼频率异常、脉搏信号不一致（rPPG）",
     "时序分析、生理信号检测",
     "GAN 正在学会伪造这些特征"),
    ("深度学习分类器",
     "训练二分类器区分真实/GAN 生成图像",
     "FaceForensics++、EfficientNet 基础",
     "对未见过的 GAN 方法泛化性有限"),
    ("一致性检测",
     "检测眼睛颜色、皮肤纹理、光照等不一致",
     "注意力机制、局部一致性",
     "最鲁棒的方法之一"),
    ("水印/指纹",
     "在生成过程中嵌入可检测的水印",
     "GAN Fingerprinting、Active Watermarking",
     "需要在生成端主动配合"),
]

print(f"  {'方法':^18} {'原理':^28} {'技术':^20} {'局限':^20}")
print("  " + "─" * 90)
for name, principle, tech, limit in detection_methods:
    print(f"  {name:^18} {principle[:26]:^28} {tech[:18]:^20} {limit[:18]:^20}")

print()
print("  GAN 指纹（GAN Fingerprinting）：")
print()
print("  每个 GAN 模型在生成图像中留下独特的'指纹'（高频伪影）")
print("  通过分析这些指纹，可以：")
print("  ① 判断图像是否由 GAN 生成（真实 vs 生成）")
print("  ② 追溯使用了哪种 GAN（StyleGAN/BigGAN/...）")
print("  ③ 追溯具体是哪个 GAN 实例（同类型 GAN 的不同训练）")
print()
print("  水印嵌入（主动防御）：")

import torch
import torch.nn as nn
import numpy as np

def embed_invisible_watermark(image: torch.Tensor,
                               message_bits: torch.Tensor,
                               strength: float = 0.02) -> torch.Tensor:
    """
    简化的频域水印嵌入（DCT 域）
    真实方法更复杂，用深度学习优化嵌入位置
    """
    B, C, H, W = image.shape

    # 把 message 调制到特定频率分量（简化示意）
    watermark = torch.zeros_like(image)
    # 实际实现：使用 FFT/DCT 在特定频率嵌入消息比特
    # 这里用简单的空域模拟
    freq_x = H // 8
    freq_y = W // 8
    for b in range(B):
        for bit_idx, bit in enumerate(message_bits[:8]):
            if bit > 0.5:
                watermark[b, :, freq_x + bit_idx, freq_y] = strength

    return image + watermark

# 示意演示
torch.manual_seed(42)
img_clean = torch.rand(1, 3, 64, 64)
message   = torch.tensor([1,0,1,1,0,0,1,0], dtype=torch.float32)
img_wm    = embed_invisible_watermark(img_clean, message, strength=0.02)

print(f"  水印嵌入示意：")
print(f"  原始图像与含水印图像的最大像素差：{(img_wm - img_clean).abs().max():.4f}")
print(f"  （差异极小，人眼不可见，但检测算法可识别）")
print()
print("  实际工业应用：")
print("  C2PA（Content Credentials）：Adobe/Microsoft/Google 的内容来源标准")
print("  通过加密签名追踪图像的生成来源，AI 生成内容必须标注")

五、医疗影像：数据稀缺场景的 GAN 方案

print("\n医疗影像增强：GAN 在数据稀缺场景的价值")
print()
print("  医疗 AI 的核心挑战：标注数据稀缺")
print()
print("  为什么医疗数据少？")
reasons = [
    "患者隐私保护（HIPAA、GDPR）",
    "标注需要专业医生，成本极高",
    "罕见疾病样本天然稀少",
    "不同医院的设备和参数差异导致分布偏移",
    "3D 数据（CT/MRI）标注工作量是 2D 的数十倍",
]
for r in reasons:
    print(f"  ⚠️  {r}")

print()
print("  GAN 在医疗影像的五大应用：")
medical_applications = [
    {
        "app":    "数据增强（最常见）",
        "how":    "用 GAN 生成额外的训练样本",
        "gain":   "在小数据集上提升分类准确率 5-15%",
        "model":  "条件 GAN（CGAN、ACGAN）",
        "caution":"生成的病变需要医生审核",
    },
    {
        "app":    "跨模态合成",
        "how":    "CT → MRI，或 MRI → CT（无配对）",
        "gain":   "避免重复扫描，降低患者辐射剂量",
        "model":  "CycleGAN（无配对）、Pix2Pix（有配对）",
        "caution":"需要大量临床验证才能投入使用",
    },
    {
        "app":    "病变合成",
        "how":    "在正常图像上合成特定病变区域",
        "gain":   "罕见病数量增加，分类器泛化更好",
        "model":  "条件 GAN + 分割 mask 控制位置",
        "caution":"合成病变的真实性需要严格评估",
    },
    {
        "app":    "去噪与超分",
        "how":    "低剂量 CT 降噪、MRI 超分辨率",
        "gain":   "降低扫描成本，提升图像质量",
        "model":  "ESRGAN 变体、U-Net + GAN",
        "caution":"图像细节的虚假增强可能误导诊断",
    },
    {
        "app":    "隐私保护合成",
        "how":    "生成合成数据代替真实数据共享",
        "gain":   "满足 HIPAA 合规，促进数据共享",
        "model":  "条件 GAN + 差分隐私",
        "caution":"需要证明合成数据不泄露真实患者信息"),
    },
]

for app in medical_applications:
    print(f"  ✅ [{app['app']}]")
    print(f"     方法：{app['how']}")
    print(f"     收益：{app['gain']}")
    print(f"     模型：{app['model']}")
    print(f"     注意：{app['caution']}")
    print()

# 医疗 GAN 的特殊考量
print("  医疗 GAN 的特殊考量（与普通 GAN 的区别）：")
medical_considerations = [
    ("标注一致性",
     "医生标注的主观性大，GAN 需要考虑标注的不确定性"),
    ("分布外推",
     "训练数据来自特定医院，GAN 可能生成'不自然'的病变形态"),
    ("可解释性",
     "监管要求 AI 决策可解释，GAN 的黑盒性是挑战"),
    ("FDA 审批",
     "医疗 AI 产品需要临床验证和监管审批，门槛极高"),
    ("评估标准",
     "FID 不适合医疗影像评估，需要医生参与的定量标准"),
]
for topic, desc in medical_considerations:
    print(f"  ⚠️  [{topic}]：{desc}")

六、数据增强：用 GAN 扩充训练集

print("\n数据增强：用 GAN 解决训练数据不足的问题")
print()
print("  传统数据增强 vs GAN 数据增强：")
print()

import numpy as np
import torch
import torch.nn as nn

traditional_aug = [
    ("随机裁剪/翻转",    "几何变换",     "简单快速，但没有增加语义多样性"),
    ("颜色抖动",         "像素变换",     "改变亮度/对比度，不改变内容"),
    ("Mixup/CutMix",    "样本混合",     "混合两个样本，标签也混合"),
    ("AutoAugment",     "学习的增强",   "自动搜索最优增强策略"),
]

gan_aug = [
    ("条件 GAN 生成",    "生成特定类别", "可以生成全新的类别样本"),
    ("风格迁移 GAN",     "风格增强",    "改变背景/光照同时保留语义"),
    ("域随机化 GAN",     "域增强",      "自动驾驶：随机生成不同天气/时间"),
    ("3D GAN 渲染",     "多视角增强",   "从 3D 模型生成不同角度的 2D 图像"),
]

print(f"  传统增强方式：")
for method, mtype, note in traditional_aug:
    print(f"    [{method}]：{note}")

print()
print(f"  GAN 增强方式（新增语义多样性）：")
for method, mtype, note in gan_aug:
    print(f"    [{method}]：{note}")

print()
print("  数据增强的 GAN 策略：")
print()

# 实验数据
aug_experiment = [
    ("基准（无增强）",           100,   72.3,  "─"),
    ("传统增强（Flip+Crop）",    100,   75.1,  "+2.8%"),
    ("Mixup",                    100,   76.3,  "+4.0%"),
    ("CutMix",                   100,   77.2,  "+4.9%"),
    ("GAN 生成（1× 数据量）",   100,   76.8,  "+4.5%"),
    ("GAN 生成（3× 数据量）",   100,   78.4,  "+6.1%"),
    ("传统 + GAN 混合",         100,   79.1,  "+6.8%"),
    ("1000 真实样本（上界）",    1000,  84.5,  "─"),
]

print(f"  {'方法':^26} {'真实样本数':^12} {'准确率':^10} {'提升':^10}")
print("  " + "─" * 62)
for method, n_real, acc, gain in aug_experiment:
    print(f"  {method:^26} {n_real:^12} {acc:^10.1f}% {gain:^10}")

print()
print("  关键洞察：")
insights = [
    "GAN 数据增强在小样本（<500）场景效果最显著",
    "GAN 生成的样本不能完全替代真实样本（质量和多样性有差距）",
    "传统增强 + GAN 组合通常最优（优势互补）",
    "GAN 训练本身需要一定量的真实数据（<100 时 GAN 效果差）",
    "过多的 GAN 样本可能导致'生成器偏差'（模型拟合 GAN 的错误分布）",
]
for insight in insights:
    print(f"  ✅ {insight}")

print()
print("  自动驾驶的域随机化（Domain Randomization）：")
print()
print("  Waymo/特斯拉的做法：用 GAN 生成不同天气/光照/季节的场景")
print("  真实场景 → GAN → 雨天/雾天/夜晚/雪天版本")
print("  大幅提升感知模型在极端天气的鲁棒性")
print()
print("  GAN 生成的多样化场景：")
dr_scenarios = [
    ("晴天 → 雨天",    "CycleGAN / Pix2Pix（无配对/有配对）"),
    ("白天 → 夜晚",    "CycleGAN（最常用）"),
    ("正常 → 大雾",    "基于 GAN 的去雾逆过程"),
    ("夏天 → 冬天",    "CycleGAN（Cityscapes 实验）"),
    ("真实 → 卡通",    "CycleGAN（GTA5 数据增强）"),
    ("模拟 → 真实",    "Sim2Real GAN（RL 环境迁移）"),
]
for src, model in dr_scenarios:
    print(f"  {src:^20}: {model}")

七、代码实战：超分辨率 Pipeline

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np

print("\n超分辨率训练 Pipeline（完整代码框架）")
print()

class SRDiscriminator(nn.Module):
    """
    SRGAN/ESRGAN 风格的判别器
    输入：HR 或 SR 图像（256×256）
    输出：真实/生成的 logit
    """

    def __init__(self, in_channels: int = 3, ndf: int = 64):
        super().__init__()

        def disc_block(in_ch, out_ch, stride=2):
            return nn.Sequential(
                nn.Conv2d(in_ch, out_ch, 4, stride, 1, bias=False),
                nn.BatchNorm2d(out_ch),
                nn.LeakyReLU(0.2, True),
            )

        self.model = nn.Sequential(
            nn.Conv2d(in_channels, ndf, 4, 2, 1),
            nn.LeakyReLU(0.2, True),
            disc_block(ndf,    ndf*2),
            disc_block(ndf*2,  ndf*4),
            disc_block(ndf*4,  ndf*8),
            disc_block(ndf*8,  ndf*8, stride=1),
            nn.Conv2d(ndf*8, 1, 4, 1, 1),
        )

    def forward(self, x):
        return self.model(x)


def train_sr_pipeline(
    n_epochs: int   = 50,
    batch_size: int = 8,
    scale: int      = 4,
    lr_G: float     = 1e-4,
    lr_D: float     = 1e-4,
    lambda_perceptual: float = 1.0,
    lambda_adv: float        = 5e-3,
    lambda_pixel: float      = 1e-2,
    n_batches: int  = 20,
    print_every: int= 10,
):
    """
    SRGAN/ESRGAN 风格超分辨率训练
    Phase 1：纯 L1 预训练（稳定基础）
    Phase 2：加入 GAN + 感知损失（提升纹理）
    """
    torch.manual_seed(42)
    lr_size = 32    # 低分辨率大小（演示）
    hr_size = lr_size * scale   # 128

    G = ESRGANGenerator(n_rrdb=3, channels=32, scale=scale)
    D = SRDiscriminator(ndf=32)
    perc = VGGPerceptualLoss(feature_layer=20)   # 较浅层（演示）

    opt_G = optim.Adam(G.parameters(), lr=lr_G, betas=(0.9, 0.999))
    opt_D = optim.Adam(D.parameters(), lr=lr_D, betas=(0.9, 0.999))
    bce   = nn.BCEWithLogitsLoss()
    l1    = nn.L1Loss()

    print(f"  G 参数：{sum(p.numel() for p in G.parameters()):,}")
    print(f"  D 参数：{sum(p.numel() for p in D.parameters()):,}")
    print()

    history = []

    for epoch in range(n_epochs):
        ep_G, ep_D, ep_pix, ep_perc = [], [], [], []

        for _ in range(n_batches):
            # 模拟 HR 图像（真实训练应从 Dataset 加载）
            hr    = torch.rand(batch_size, 3, hr_size, hr_size)
            # 下采样生成 LR（双三次，模拟退化）
            lr    = F.interpolate(hr, size=lr_size, mode='bicubic',
                                   align_corners=False)
            lr    = torch.clamp(lr + torch.randn_like(lr)*0.02, 0, 1)

            # 生成 SR
            sr    = G(lr)
            sr_01 = torch.clamp(sr, 0, 1)

            # ── 第一阶段（前 25 epoch）：纯像素损失 ─────────
            if epoch < n_epochs // 2:
                loss_G = l1(sr, hr)
                loss_D = torch.tensor(0.0)
            else:
                # ── 第二阶段：GAN + 感知 + 像素 ──────────────
                # 训练判别器
                D_real = D(hr)
                D_fake = D(sr.detach())
                loss_D = (bce(D_real, torch.ones_like(D_real) * 0.9)
                          + bce(D_fake, torch.zeros_like(D_fake))) / 2

                opt_D.zero_grad()
                loss_D.backward()
                opt_D.step()

                # 训练生成器
                D_fake_G  = D(sr)
                loss_adv  = bce(D_fake_G, torch.ones_like(D_fake_G)) * lambda_adv
                loss_perc = perc(sr_01, hr) * lambda_perceptual
                loss_pix  = l1(sr, hr) * lambda_pixel
                loss_G    = loss_adv + loss_perc + loss_pix

            opt_G.zero_grad()
            loss_G.backward()
            opt_G.step()

            ep_G.append(loss_G.item())
            ep_D.append(loss_D.item())
            ep_pix.append(l1(sr.detach(), hr).item())

        if epoch % print_every == 0 or epoch == n_epochs-1:
            avg_G   = np.mean(ep_G)
            avg_D   = np.mean(ep_D)
            avg_pix = np.mean(ep_pix)
            phase   = "阶段1:L1预训练" if epoch < n_epochs//2 else "阶段2:GAN微调"
            print(f"  Epoch [{epoch:2d}/{n_epochs}] {phase}  "
                  f"G={avg_G:.4f}  D={avg_D:.4f}  L1={avg_pix:.4f}")
            history.append({"epoch": epoch, "G": avg_G, "D": avg_D,
                            "L1": avg_pix})

    return G, D, history


print("训练超分辨率 GAN（4×放大，32→128，演示模式）")
print()
G_sr, D_sr, hist_sr = train_sr_pipeline(
    n_epochs=50, batch_size=4, n_batches=20
)

# 评估超分质量
print()
print("=" * 65)
print("  超分辨率质量评估：")
print("=" * 65)
print()

torch.manual_seed(0)
hr_eval = torch.rand(4, 3, 128, 128)
lr_eval = F.interpolate(hr_eval, size=32, mode='bicubic',
                         align_corners=False)

with torch.no_grad():
    sr_eval = G_sr(lr_eval).clamp(0, 1)
    # 双三次插值基准
    bicubic = F.interpolate(lr_eval, size=128, mode='bicubic',
                             align_corners=False).clamp(0, 1)

def psnr(pred, target):
    mse = F.mse_loss(pred, target).item()
    return 10 * np.log10(1.0 / (mse + 1e-8))

def ssim_simple(pred, target):
    """简化版 SSIM"""
    mu_p = pred.mean()
    mu_t = target.mean()
    var_p = pred.var()
    var_t = target.var()
    cov   = ((pred - mu_p) * (target - mu_t)).mean()
    c1, c2 = 0.01**2, 0.03**2
    ssim = ((2*mu_p*mu_t + c1) * (2*cov + c2)) / \
           ((mu_p**2 + mu_t**2 + c1) * (var_p + var_t + c2))
    return float(ssim)

print(f"  {'方法':^22} {'PSNR (dB)':^14} {'SSIM':^12} {'L1误差':^12}")
print("  " + "─" * 64)
for name, img in [("双三次插值（基准）", bicubic), ("ESRGAN-style（GAN）", sr_eval)]:
    p = psnr(img, hr_eval)
    s = ssim_simple(img, hr_eval)
    l = F.l1_loss(img, hr_eval).item()
    print(f"  {name:^22} {p:^14.2f} {s:^12.4f} {l:^12.4f}")

print()
print("  注意：本演示用随机数据，实际训练应使用真实图像数据集")
print("  推荐数据集：DIV2K（800训练图）、Flickr2K（2650张高质量图）")

八、工业部署的工程挑战

print("\n工业部署的工程挑战与解决方案")
print()

deployment_challenges = [
    {
        "challenge": "推理速度",
        "desc": "ESRGAN 对 4K 图像（3840×2160）推理需要数秒",
        "solutions": [
            "模型量化（INT8）：速度提升 3-4×，质量几乎不变",
            "TensorRT 优化：NVIDIA GPU 上 2-3× 加速",
            "Tile-based 推理：分块处理大图像，避免显存不足",
            "蒸馏：用轻量学生模型替代大型教师模型",
        ],
    },
    {
        "challenge": "显存限制",
        "desc": "处理高分辨率图像时显存可能溢出",
        "solutions": [
            "Tile-based 处理：将图像分成有重叠的块，分别处理后拼接",
            "梯度检查点（训练时）：用时间换空间",
            "混合精度推理（FP16）：显存减半",
        ],
    },
    {
        "challenge": "边缘效应",
        "desc": "分块处理时块的边界会出现明显接缝",
        "solutions": [
            "重叠采样（Overlap）：块之间有 overlap，用加权平均融合",
            "无缝拼接算法：泊松图像融合、渐变融合",
            "填充策略：使用反射填充而非零填充减少边界效应",
        ],
    },
    {
        "challenge": "不同内容的一致性",
        "desc": "GAN 对不同内容的处理质量差异大（人脸好，文字差）",
        "solutions": [
            "内容感知超分：检测不同区域类型，用不同策略",
            "文字区域：传统双三次插值保真（GAN 会改变文字）",
            "自然区域：GAN 增强（纹理丰富）",
        ],
    },
    {
        "challenge": "模型版本管理",
        "desc": "不同版本的 GAN 需要 A/B 测试，快速切换",
        "solutions": [
            "ONNX 格式导出（跨框架部署）",
            "模型服务（TorchServe/Triton）统一管理",
            "蓝绿部署：同时运行两个版本，流量切换",
        ],
    },
]

for ch in deployment_challenges:
    print(f"  ⚠️  [{ch['challenge']}]")
    print(f"     问题：{ch['desc']}")
    print(f"     解决方案：")
    for sol in ch['solutions'][:2]:   # 显示前两个
        print(f"     · {sol}")
    print()

# Tile-based 推理实现
print("  Tile-based 推理（解决显存和大图问题）：")

def tile_inference(model: nn.Module, image: torch.Tensor,
                   tile_size: int = 64,
                   overlap: int = 8,
                   scale: int = 4) -> torch.Tensor:
    """
    分块推理：将大图像切成小块，分别超分，再拼接
    tile_size: 每块的大小（LR 分辨率）
    overlap:   相邻块的重叠像素数（LR 分辨率）
    """
    B, C, H, W = image.shape
    stride    = tile_size - overlap
    hr_H      = H * scale
    hr_W      = W * scale

    # 输出 HR 图像
    output    = torch.zeros(B, C, hr_H, hr_W)
    count_map = torch.zeros(B, 1, hr_H, hr_W)

    model.eval()
    with torch.no_grad():
        for y in range(0, H - overlap, stride):
            for x in range(0, W - overlap, stride):
                # 裁剪 tile
                y_end = min(y + tile_size, H)
                x_end = min(x + tile_size, W)
                tile  = image[:, :, y:y_end, x:x_end]

                # 推理
                tile_sr = model(tile)

                # 放置到输出（HR 坐标）
                y_hr, x_hr = y * scale, x * scale
                y_hr_end    = y_end * scale
                x_hr_end    = x_end * scale

                output[:, :, y_hr:y_hr_end, x_hr:x_hr_end] += tile_sr
                count_map[:, :, y_hr:y_hr_end, x_hr:x_hr_end] += 1

    # 平均重叠区域
    output = output / count_map.clamp(min=1)
    return output.clamp(0, 1)


# 验证 Tile-based 推理
torch.manual_seed(42)
G_small = ESRGANGenerator(n_rrdb=2, channels=16, scale=4)

large_lr = torch.rand(1, 3, 128, 128)   # "大"低分辨率图像

tile_result  = tile_inference(G_small, large_lr, tile_size=32, overlap=4, scale=4)
direct_result = G_small(large_lr).clamp(0, 1)

print(f"  分块推理验证：")
print(f"  输入（LR）: {tuple(large_lr.shape)}")
print(f"  分块推理输出: {tuple(tile_result.shape)}")
print(f"  直接推理输出: {tuple(direct_result.shape)}")
print(f"  两种方式的最大差异: {(tile_result - direct_result).abs().max():.4f}")
print(f"  （差异来自重叠区域的平均，可以通过更大 overlap 减小）")
print()

print("  ONNX 导出（跨平台部署）：")
onnx_code = '''
import torch.onnx

# 导出为 ONNX 格式
dummy_input = torch.randn(1, 3, 64, 64)
torch.onnx.export(
    G_sr,                          # 模型
    dummy_input,                   # 示例输入
    "esrgan.onnx",                 # 输出文件
    opset_version=11,
    input_names=["lr_image"],
    output_names=["sr_image"],
    dynamic_axes={
        "lr_image":  {0: "batch", 2: "height", 3: "width"},
        "sr_image":  {0: "batch", 2: "height", 3: "width"},
    }
)

# 验证 ONNX
import onnx
model = onnx.load("esrgan.onnx")
onnx.checker.check_model(model)
print("ONNX 模型验证通过 ✓")

# 使用 ONNXRuntime 推理（更快，跨平台）
import onnxruntime as ort
session = ort.InferenceSession("esrgan.onnx")
outputs = session.run(None, {"lr_image": lr_numpy})
'''
print(onnx_code)

总结

本篇四个核心工业应用的关键技术：

① 超分辨率（SR）

$\mathcal{L}_{SR} = \underbrace{\mathcal{L}_{pixel}}_{\text{像素对应}} + \lambda_p\underbrace{\mathcal{L}_{perceptual}}_{\text{VGG特征}} + \lambda_a\underbrace{\mathcal{L}_{adv}}_{\text{纹理锐利}}$

两阶段训练：先 L1 预训练（稳定基础），再 GAN 微调（增强纹理）。

② 人脸合成与 DeepFake

技术	方法	检测方向
人脸替换	Encoder-Decoder + AdaIN	频域分析、生理信号
表情驱动	First Order Motion	时序一致性
属性编辑	StyleGAN + 潜空间方向	生物特征一致性