GAN 生成对抗网络原理与应用

import torch
import torch.nn as nn

class SimpleGenerator(nn.Module):
    """生成器：将噪声映射到数据空间"""
    def __init__(self, latent_dim=100, output_dim=784):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(latent_dim, 256),
            nn.LeakyReLU(0.2),
            nn.Linear(256, 512),
            nn.LeakyReLU(0.2),
            nn.Linear(512, output_dim),
            nn.Tanh()  # 输出归一化到 [-1, 1]
        )

    def forward(self, z):
        return self.net(z)

class SimpleDiscriminator(nn.Module):
    """判别器：判断样本真假"""
    def __init__(self, input_dim=784):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(input_dim, 512),
            nn.LeakyReLU(0.2),
            nn.Linear(512, 256),
            nn.LeakyReLU(0.2),
            nn.Linear(256, 1),
            nn.Sigmoid()  # 输出概率
        )

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

def train_gan_step(G, D, real_data, latent_dim, device):
    """原始 GAN 的一次训练迭代"""
    batch_size = real_data.size(0)

    # ===== 1. 训练判别器 D =====
    real_labels = torch.ones(batch_size, 1, device=device)
    fake_labels = torch.zeros(batch_size, 1, device=device)

    # 真实样本的损失
    real_output = D(real_data)
    d_loss_real = nn.BCELoss()(real_output, real_labels)

    # 假样本的损失
    z = torch.randn(batch_size, latent_dim, device=device)
    fake_data = G(z).detach()  # 不计算 G 的梯度
    fake_output = D(fake_data)
    d_loss_fake = nn.BCELoss()(fake_output, fake_labels)

    d_loss = d_loss_real + d_loss_fake
    d_loss.backward()

    # ===== 2. 训练生成器 G =====
    z = torch.randn(batch_size, latent_dim, device=device)
    fake_data = G(z)
    fake_output = D(fake_data)
    # G 希望 D(G(z)) ≈ 1
    g_loss = nn.BCELoss()(fake_output, real_labels)
    g_loss.backward()

    return d_loss.item(), g_loss.item()

import torch.nn as nn

class DCGAN_Generator(nn.Module):
    """DCGAN 生成器：从噪声到图像"""
    def __init__(self, latent_dim=100, ngf=64, nc=3):
        super().__init__()
        self.main = nn.Sequential(
            # 输入: z [N, 100, 1, 1]
            nn.ConvTranspose2d(latent_dim, ngf * 8, 4, 1, 0, bias=False),
            nn.BatchNorm2d(ngf * 8),
            nn.ReLU(True),
            # 输出: [N, 512, 4, 4]
            nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf * 4),
            nn.ReLU(True),
            # 输出: [N, 256, 8, 8]
            nn.ConvTranspose2d(ngf * 4, ngf * 2, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf * 2),
            nn.ReLU(True),
            # 输出: [N, 128, 16, 16]
            nn.ConvTranspose2d(ngf * 2, ngf, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf),
            nn.ReLU(True),
            # 输出: [N, 64, 32, 32]
            nn.ConvTranspose2d(ngf, nc, 4, 2, 1, bias=False),
            nn.Tanh()
            # 输出: [N, 3, 64, 64]
        )

    def forward(self, z):
        return self.main(z)

class DCGAN_Discriminator(nn.Module):
    """DCGAN 判别器"""
    def __init__(self, nc=3, ndf=64):
        super().__init__()
        self.main = nn.Sequential(
            nn.Conv2d(nc, ndf, 4, 2, 1, bias=False),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 2),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 4),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 8),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Conv2d(ndf * 8, 1, 4, 1, 0, bias=False),
            nn.Sigmoid()
        )

    def forward(self, x):
        return self.main(x).view(-1, 1)

import torch
import torch.nn as nn

def wgan_gp_loss(critic, real_data, fake_data, device, lambda_gp=10):
    """WGAN-GP 的 Critic 损失（含梯度惩罚）"""
    batch_size = real_data.size(0)

    # Critic 对真实/假样本的打分
    real_score = critic(real_data).view(-1)
    fake_score = critic(fake_data.detach()).view(-1)

    # Wasserstein 距离估计
    critic_loss = fake_score.mean() - real_score.mean()

    # ===== 梯度惩罚 =====
    # 随机插值：x̂ = ε·x_real + (1-ε)·x_fake
    eps = torch.rand(batch_size, 1, 1, 1, device=device)
    x_hat = eps * real_data + (1 - eps) * fake_data.detach()
    x_hat.requires_grad_(True)

    hat_score = critic(x_hat).view(-1)
    grad = torch.autograd.grad(
        outputs=hat_score,
        inputs=x_hat,
        grad_outputs=torch.ones_like(hat_score),
        create_graph=True
    )[0]

    grad_norm = grad.view(batch_size, -1).norm(2, dim=1)
    gp = ((grad_norm - 1) ** 2).mean()

    return critic_loss + lambda_gp * gp

def generator_loss(critic, fake_data):
    """WGAN 中生成器的损失"""
    fake_score = critic(fake_data).view(-1)
    return -fake_score.mean()  # 最大化 Critic 对假样本的打分

import torch
import torch.nn as nn
import torch.nn.functional as F

class AdaIN(nn.Module):
    """自适应实例归一化"""
    def __init__(self, channels, style_dim=512):
        super().__init__()
        self.norm = nn.InstanceNorm2d(channels, affine=False)
        self.style_scale = nn.Linear(style_dim, channels)
        self.style_bias = nn.Linear(style_dim, channels)

    def forward(self, x, w):
        # 归一化
        out = self.norm(x)
        # 从 w 预测仿射参数
        scale = self.style_scale(w).view(x.size(0), -1, 1, 1)
        bias = self.style_bias(w).view(x.size(0), -1, 1, 1)
        return out * (scale + 1) + bias

class StyleGAN2Generator(nn.Module):
    """StyleGAN2 生成器的简化版本"""
    def __init__(self, latent_dim=512, ngf=64):
        super().__init__()
        self.mapping = nn.Sequential(
            *[nn.Linear(latent_dim, latent_dim), nn.LeakyReLU(0.2)
              for _ in range(8)]
        )
        # 4x4 常量输入 + 卷积
        self.const = nn.Parameter(torch.randn(1, ngf * 8, 4, 4))
        self.adain1 = AdaIN(ngf * 8, latent_dim)
        self.conv1 = nn.Conv2d(ngf * 8, ngf * 8, 3, padding=1)

    def forward(self, z):
        w = self.mapping(z)  # 映射到 W 空间
        x = self.const.expand(z.size(0), -1, -1, -1)
        x = self.adain1(x, w)
        x = F.leaky_relu(self.conv1(x), 0.2)
        # 后续层继续上采样...
        return x

import torch
import torch.nn as nn
import torch.nn.functional as F

class ResBlock(nn.Module):
    """CycleGAN 生成器的残差块"""
    def __init__(self, channels):
        super().__init__()
        self.block = nn.Sequential(
            nn.ReflectionPad2d(1),
            nn.Conv2d(channels, channels, 3),
            nn.InstanceNorm2d(channels),
            nn.ReLU(True),
            nn.ReflectionPad2d(1),
            nn.Conv2d(channels, channels, 3),
            nn.InstanceNorm2d(channels),
        )

    def forward(self, x):
        return x + self.block(x)  # 残差连接

class CycleGANGenerator(nn.Module):
    """CycleGAN 生成器：下采样 + 残差 + 上采样"""
    def __init__(self, nc=3, ngf=64, n_blocks=6):
        super().__init__()
        # 下采样
        self.down = nn.Sequential(
            nn.ReflectionPad2d(3),
            nn.Conv2d(nc, ngf, 7, padding=0),
            nn.InstanceNorm2d(ngf), nn.ReLU(True),
            nn.Conv2d(ngf, ngf*2, 3, stride=2, padding=1),
            nn.InstanceNorm2d(ngf*2), nn.ReLU(True),
            nn.Conv2d(ngf*2, ngf*4, 3, stride=2, padding=1),
            nn.InstanceNorm2d(ngf*4), nn.ReLU(True),
        )
        # 残差块
        self.residuals = nn.Sequential(*[ResBlock(ngf*4) for _ in range(n_blocks)])
        # 上采样（用插值代替转置卷积，避免棋盘效应）
        self.up = nn.Sequential(
            nn.Upsample(scale_factor=2, mode='bilinear'),
            nn.Conv2d(ngf*4, ngf*2, 3, padding=1),
            nn.InstanceNorm2d(ngf*2), nn.ReLU(True),
            nn.Upsample(scale_factor=2, mode='bilinear'),
            nn.Conv2d(ngf*2, ngf, 3, padding=1),
            nn.InstanceNorm2d(ngf), nn.ReLU(True),
            nn.ReflectionPad2d(3),
            nn.Conv2d(ngf, nc, 7),
            nn.Tanh(),
        )

    def forward(self, x):
        return self.up(self.residuals(self.down(x)))

def cycle_consistency_loss(G, F, real_A, real_B):
    """循环一致性损失"""
    # A → B → A
    fake_B = G(real_A)
    rec_A = F(fake_B)
    # B → A → B
    fake_A = F(real_B)
    rec_B = G(fake_A)
    return F.l1_loss(rec_A, real_A) + F.l1_loss(rec_B, real_B)

import torch
import numpy as np
from scipy import linalg
from torchvision.models import inception_v3
from torchvision import transforms

def calculate_fid(real_features, fake_features):
    """计算 Fréchet Inception Distance (FID)
    
    FID = ||μ_r - μ_f||² + Tr(Σ_r + Σ_f - 2·√(Σ_r·Σ_f))
    越低表示生成质量越好
    """
    mu_real = np.mean(real_features, axis=0)
    mu_fake = np.mean(fake_features, axis=0)

    sigma_real = np.cov(real_features, rowvar=False)
    sigma_fake = np.cov(fake_features, rowvar=False)

    # Fréchet 距离
    diff = mu_real - mu_fake
    covmean, _ = linalg.sqrtm(sigma_real @ sigma_fake, disp=False)

    # 处理复数（数值不稳定时 sqrtm 可能返回复数）
    if np.iscomplexobj(covmean):
        covmean = covmean.real

    fid = diff @ diff + np.trace(sigma_real + sigma_fake - 2 * covmean)
    return float(fid)

def calculate_inception_score(fake_logits, splits=10):
    """计算 Inception Score (IS)
    
    IS = exp(E_y[KL(p(y|x) || p(y))])
    越高表示生成质量越好、多样性越高
    """
    scores = []
    split_size = fake_logits.shape[0] // splits

    for i in range(splits):
        logits = fake_logits[i * split_size: (i + 1) * split_size]
        probs = torch.softmax(logits, dim=1)

        # 边际分布 p(y)
        marginal = probs.mean(dim=0, keepdim=True)

        # KL 散度
        kl = probs * (torch.log(probs + 1e-10) - torch.log(marginal + 1e-10))
        kl = kl.sum(dim=1).mean()

        scores.append(torch.exp(kl).item())

    return np.mean(scores), np.std(scores)