课程11. 计算机视觉、自编码器和生成对抗网络 (GAN)

啥都鼓捣的小yao2025-05-16 8:12

计算机视觉、自编码器和生成对抗网络（GAN）

课程计划：

  1. 自动编码器：
    • 自动编码器结构；
    • 使用自动编码器生成图像；
    • 条件自动编码器；
  2. 生成对抗网络：
    • 生成对抗网络结构；
    • 练习：构建和训练生成对抗网络；

自动编码器

Autoencoders

Vanilla自动编码器

自动编码器是一种神经网络，它学习重建输入信息。换句话说，它试图产生与输入完全相同的输出：

自动编码器通常设计为向中间逐渐变细，即中间层的神经元数量远小于网络前层的神经元数量。这样我们就得到了我们熟悉的编码器-解码器结构。

如果自动编码器中间层的神经元数量与输入层相同，那么在没有额外限制的情况下，自动编码器就毫无意义。它会学习id（身份）函数。

自动编码器的用途：

  • 数据压缩和存储，特别是图像/视频压缩；
  • 根据潜在表征对对象进行聚类；
  • 查找相似对象（例如图像）；
  • 生成新对象（例如图像）。
  • 查找数据中的异常；
  • ......（可能还有更多 😃）。

自动编码器 (AE) 采用自监督学习模式进行训练。这意味着它无需数据标记即可进行训练。

例如，如果我们想在人脸图像数据集上训练 AE，那么在每次训练迭代中，我们会执行以下操作：

  • 为 AE 输入一张图片；
  • 将重建图像作为 AE 的输出；
  • 计算重建图像与输入图像之间的 MSE/BCE 质量指标；
  • 使用反向传播算法训练 AE。

与分类/检测/分割任务不同，AE 无需数据标记。

使用 AE 生成新对象. 变分 AE (VAE)

让我们更详细地讨论如何使用自编码器生成新物体。为了简单起见，我们假设处理的是人脸图像（其他类型的物体也一样）。

使用 AE 生成新图像：

  1. 在我们的人脸数据集上训练 AE；
  2. 去掉编码器部分，只留下解码器部分；
  3. 将所需大小的随机数字向量输入到解码器部分的输入中，在输出端，我们将得到一张从未见过的人脸新图像。

然而，常规（"原始"）AE 无法实现这样的效果。问题在于，它的潜在空间非常稀疏：并非空间中的每个点都对应一张真实的图片。

潜在空间看起来大致如下：

为了使自动编码器（AE）的潜在空间向量能够真正生成新的对象，我们需要强制自动编码器学习一个更连贯、更紧凑的潜在空间。

一种方法是指定潜在空间向量应该对应的分布。也就是说，对向量在潜在空间中的间距添加一个约束。

这种自动编码器被称为变分自动编码器（VAE）。它的潜在空间大致如下：

AE 条件

我们已经意识到 VAE 可以用来生成新对象。让我们来讨论一下如何生成不仅仅是任何新对象，而是具有给定属性的对象。

其思路是这样的：在训练过程中，解码器输入会输入一个编码属性以及潜在向量。例如，假设我们想要学习如何生成特定种族的人脸。假设我们只有 4 种种族类型。我们使用独热编码对它们进行编码：每种种族类型对应一个长度为 4 的向量，由 0 和 1 组成。解码器输入会输入一个潜在向量，该向量与该种族的独热向量连接在一起。

不仅可以将条件向量馈送到第一个解码器层的输入，还可以将其馈送到其所有层的输入。还可以将条件向量馈送到编码器层的输入。

问题：原始自动编码器用于什么任务的训练？

GAN

理论

GAN ------ Generative adversarial Network ------ 生成对抗网络。该架构于 2014 年发明，专门用于生成新图像（当然，GAN 不仅可以用来生成图像，还可以生成其他对象）。

让我们思考一下：如何训练神经网络生成新物体？

最简单的想法：创建一个神经网络，输入一个特定大小的随机向量，并输出一张生成的图像：

这个想法的问题在于如何训练这样的网络。如果你在训练过程中将随机向量输入到输入中，并将网络输出与训练数据集中的图片进行比较，这样的网络将学会只生成训练数据集中的图片。这几乎没什么用 =)

我希望在训练数据集有限的情况下，教会神经网络生成不同的人脸，即使是神经网络在训练过程中没有识别的人脸（即不在训练数据中的人脸）。

如何做到这一点？其中一个想法是 GAN------生成对抗网络。

它的工作原理如下：

该模型由两个独立的神经网络组成：一个生成器和一个鉴别器。生成器以随机向量作为输入，输出一张图像。鉴别器以图像作为输入，输出一个答案：这张图片是真的还是假的（由生成器生成）。

生成器和鉴别器一起训练。鉴别器帮助生成器学习生成各种图像，而不仅仅是训练数据集中的图像。

.

这一切的关键在于：鉴别器能够快速学会区分生成器生成的图片和真实图片（来自训练数据集）。之后，在生成器训练阶段，生成器会学习自适应，生成鉴别器无法再区分的图片。之后，鉴别器会学习区分生成器生成的新图片和真实图片。之后，生成器会再次学习生成更好的图片。如此反复。

这是生成器和鉴别器之间的对抗。

GAN 有一些缺点：

  • GAN 训练起来相当困难。你需要选择合适的生成器和鉴别器架构：这样鉴别器就不会比生成器"聪明"太多（学会对图片进行分类的速度不会比生成器学会生成图片的速度快太多）。反之亦然：鉴别器也不应该比生成器"笨"太多，否则生成器将无法接收到良好的训练信号。
  • 在 GAN 生成器中使用 BatchNorm 时应格外谨慎。BatchNorm 会均衡批次中所有元素的分布，因此同一批次中生成的所有图像可以具有相似的特征。
    使用 BatchNorm 生成示例：
  • GAN 通常存在一种崩溃模式：生成器开始针对任何随机输入向量生成大致相同的图像。有许多技术可以减少这种影响，并使生成器的生成更加多样化。崩溃模式的示例如下：

示例

让我们教 GAN 生成人脸。我们将使用 LFW 数据集

我们导入必要的库：

python 复制代码 
import numpy as np
import os
from PIL import Image
import matplotlib.pyplot as plt
from IPython.display import clear_output

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import Dataset, DataLoader

from torchvision import transforms

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
device

输出：

device(type='cuda')

下文将介绍如何下载和准备数据。所有代码与上面 AE 练习中的代码类似。如果您之前未下载过此笔记本中的数据，则需要取消注释并运行本节中的单元格。

下载并准备数据

python 复制代码 
!pip install deeplake==3.0
python 复制代码 
import deeplake
ds = deeplake.load('hub://activeloop/lfw')
python 复制代码 
dataloader = ds.pytorch(num_workers = 1, batch_size=1, shuffle = False)
python 复制代码 
import tqdm
from tqdm.auto import tqdm as tqdm
import PIL
faces = []
for b in tqdm(dataloader):
   faces.append(PIL.Image.fromarray(b['images'][0].detach().numpy()))

输出：

python 复制代码 
class Faces(Dataset):
    def __init__(self, faces):
        self.data = faces
        self.transform = transforms.Compose([
                                    transforms.CenterCrop((90, 90)),
                                    transforms.Resize((64, 64)),
                                    transforms.ToTensor(),
                                    # transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))
                                    ])

    def __getitem__(self, index):

        x = self.data[index]
        return self.transform(x).float()

    def __len__(self):
        return len(self.data)
python 复制代码 
def plot_gallery(images, n_row=3, n_col=6, from_torch=False):
    """Helper function to plot a gallery of portraits"""

    if from_torch:
        images = [x.data.numpy().transpose(1, 2, 0) for x in images]

    plt.figure(figsize=(1.5 * n_col, 1.7 * n_row))
    plt.subplots_adjust(bottom=0, left=.01, right=.99, top=.90, hspace=.35)

    for i in range(n_row * n_col):
        plt.subplot(n_row, n_col, i + 1)
        plt.imshow(images[i])

        plt.xticks(())
        plt.yticks(())

    plt.show()
python 复制代码 
dataset = Faces(faces)

# dataset[0] 是对 __getitem__(0) 方法的调用
img = dataset[0]

print(img.shape)

# 绘制图像及其分割蒙版
plot_gallery(dataset, from_torch=True)

输出：

python 复制代码 
train_size = int(len(dataset) * 0.8)
val_size = len(dataset) - train_size

g_cpu = torch.Generator().manual_seed(8888)
train_data, val_data = torch.utils.data.random_split(dataset, [train_size, val_size], generator=g_cpu)

train_loader = torch.utils.data.DataLoader(train_data, batch_size=16, shuffle=True)
val_loader = torch.utils.data.DataLoader(val_data, batch_size=16, shuffle=False)

GAN模型

让我们分别声明鉴别器和生成器模型。

鉴别器模型是一个用于图像二分类的常规卷积网络：

python 复制代码 
class Discriminator(nn.Module):
    def __init__(self):
        super().__init__()
        # in: 3 x 64 x 64

        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=2, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        # out: 64 x 32 x 32

        self.conv2 = nn.Conv2d(64, 128, kernel_size=4, stride=2, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(128)
        # out: 128 x 16 x 16

        self.conv3 = nn.Conv2d(128, 256, kernel_size=4, stride=2, padding=1, bias=False)
        self.bn3 = nn.BatchNorm2d(256)
        # out: 256 x 8 x 8

        self.conv4 = nn.Conv2d(256, 512, kernel_size=4, stride=2, padding=1, bias=False)
        self.bn4 = nn.BatchNorm2d(512)
        # out: 512 x 4 x 4

        self.conv5 = nn.Conv2d(512, 1, kernel_size=4, stride=1, padding=0, bias=False)
        # out: 1 x 1 x 1

        self.flatten = nn.Flatten()
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):

        x = F.relu(self.bn1(self.conv1(x)))
        x = F.relu(self.bn2(self.conv2(x)))
        x = F.relu(self.bn3(self.conv3(x)))
        x = F.relu(self.bn4(self.conv4(x)))

        x = self.conv5(x)
        x = self.flatten(x)
        x = self.sigmoid(x)

        return x

生成器模型也是一个卷积神经网络，其输出必须与数据集中的图像具有相同的维度：

python 复制代码 
class Generator(nn.Module):
    def __init__(self, latent_size):
        super().__init__()
        # in: latent_size x 1 x 1

        self.convT1 = nn.ConvTranspose2d(latent_size, 512, kernel_size=4, stride=1, padding=0, bias=False)
        self.bn1 = nn.BatchNorm2d(512)
        # out: 512 x 4 x 4

        self.convT2 = nn.ConvTranspose2d(512, 256, kernel_size=4, stride=2, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(256)
        # out: 256 x 8 x 8

        self.convT3 = nn.ConvTranspose2d(256, 128, kernel_size=4, stride=2, padding=1, bias=False)
        self.bn3 = nn.BatchNorm2d(128)
        # out: 128 x 16 x 16

        self.convT4 = nn.ConvTranspose2d(128, 64, kernel_size=4, stride=2, padding=1, bias=False)
        self.bn4 = nn.BatchNorm2d(64)
        # out: 64 x 32 x 32

        self.convT5 = nn.ConvTranspose2d(64, 3, kernel_size=4, stride=2, padding=1, bias=False)
        self.tanh = nn.Tanh()
        # out: 3 x 64 x 64

    def forward(self, x):

        x = F.relu(self.bn1(self.convT1(x)))
        x = F.relu(self.bn2(self.convT2(x)))
        x = F.relu(self.bn3(self.convT3(x)))
        x = F.relu(self.bn4(self.convT4(x)))

        x = self.convT5(x)
        x = self.tanh(x)

        return x

我们将输入生成器以生成图像的随机向量的大小设置为 128：

python 复制代码 
latent_size = 128

让我们引入一个固定的噪声向量，以便在网络训练过程中我们可以跟踪生成器输出在这个固定向量上的变化：

python 复制代码 
fixed_latent = torch.randn(64, latent_size, 1, 1, device=device)

现在让我们开始训练 GAN. 训练算法如下：

  1. 训练鉴别器：

    • 拍摄真实图像并赋予其标签 1
    • 使用生成器生成图像并赋予其标签 0
    • 将分类器训练成两类

  2. 训练生成器：

    • 使用生成器生成图像并赋予其标签 0
    • 使用鉴别器预测图像是否真实
python 复制代码 
from IPython.display import clear_output
from torchvision.utils import make_grid

# 用于对图像进行反规范化的函数
stats = (0.5, 0.5, 0.5), (0.5, 0.5, 0.5)
def denorm(img_tensors):
    return img_tensors * stats[1][0] + stats[0][0]

# 用于绘制图像生成器生成结果的函数
# 在我们的固定噪声向量上
def show_samples(latent_tensors):
    fake_images = generator(latent_tensors)

    fig, ax = plt.subplots(figsize=(8, 8))
    ax.set_xticks([]); ax.set_yticks([])
    ax.imshow(make_grid(denorm(fake_images[:64].cpu().detach()), nrow=8).permute(1, 2, 0))
    plt.show()

# GAN的直接学习函数
def train(models, opts, loss_fns, epochs, train_loader, val_loader, batch_size=64):

    # Losses & scores
    losses_g = []
    losses_d = []
    real_scores = []
    fake_scores = []

    for epoch in range(epochs):
        # 打印当前epoch
        print('* Epoch %d/%d' % (epoch+1, epochs))

        # 使用来自 train_loader 的图像来训练网络
        models["discriminator"].train()
        models["generator"].train()

        # 用于存储损失值和准确率指标的数组
        # 网络训练期间的鉴别器
        loss_d_per_epoch = []
        loss_g_per_epoch = []
        real_score_per_epoch = []
        fake_score_per_epoch = []

        for i, X_batch in enumerate(train_loader):
            X_batch = X_batch.to(device)

            # 1. 鉴别器训练步骤。

            # 清除鉴别器梯度
            opts["discriminator"].zero_grad()

            # 1.1 真实图片出现亏损

            # 我们将批次 X_batch 中的真实图像输入到鉴别器的输入中
            real_preds = models["discriminator"](X_batch)
            # 鉴别器对这些图像的正确响应应该是一个由 1 组成的向量
            real_targets = torch.ones(X_batch.size(0), 1, device=device)
            # 我们在一批真实图像上计算鉴别器损失值
            real_loss = loss_fns["discriminator"](real_preds, real_targets)
            cur_real_score = torch.mean(real_preds).item()

            # 1.2 因假图片而蒙受损失

            # 让我们生成虚假图像。为此，我们生成一个大小为 (batch_size, latent_size, 1, 1) 的随机噪声向量，并将其输入到生成器中。
            latent = torch.randn(batch_size, latent_size, 1, 1, device=device)
            # 我们得到一批随机向量的生成器输出
            fake_images = models["generator"](latent)

            # 我们将来自批次 X_batch 的假图像输入到鉴别器的输入中
            fake_preds = models["discriminator"](fake_images)
            # 鉴别器对这些图像的正确响应应该是一个零向量
            fake_targets = torch.zeros(fake_images.size(0), 1, device=device)
            # 计算一批假图像上的鉴别器损失值
            fake_loss = loss_fns["discriminator"](fake_preds, fake_targets)
            cur_fake_score = torch.mean(fake_preds).item()

            real_score_per_epoch.append(cur_real_score)
            fake_score_per_epoch.append(cur_fake_score)

            # 1.3 更新鉴别器权重：执行梯度下降步骤
            loss_d = real_loss + fake_loss
            loss_d.backward()
            opts["discriminator"].step()
            loss_d_per_epoch.append(loss_d.item())

            # 2. 生成器训练步骤
            # 清理生成器梯度
            opts["generator"].zero_grad()

            # 让我们生成虚假图像。为此，我们生成一个大小为 (batch_size, latent_size, 1, 1) 的随机噪声向量，并将其输入到生成器中。
            latent = torch.randn(batch_size, latent_size, 1, 1, device=device)
            # 我们得到一批随机向量的生成器输出
            fake_images = models["generator"](latent)

            # 我们将来自批次 X_batch 的假图像输入到鉴别器的输入中
            preds = models["discriminator"](fake_images)
            # 我们将这些图片的"正确"答案向量设置为 1 的向量
            targets = torch.ones(batch_size, 1, device=device)
            # 计算预测和目标之间的损失
            loss_g = loss_fns["generator"](preds, targets)

            # 更新生成器权重
            loss_g.backward()
            opts["generator"].step()
            loss_g_per_epoch.append(loss_g.item())

            # 每 100 次训练迭代，我们将输出指标的当前值
            # 并绘制图像生成器生成的结果
            # 来自固定的随机向量
            if i%100 == 0:
                # Record losses & scores
                losses_g.append(np.mean(loss_g_per_epoch))
                losses_d.append(np.mean(loss_d_per_epoch))
                real_scores.append(np.mean(real_score_per_epoch))
                fake_scores.append(np.mean(fake_score_per_epoch))

                # Log losses & scores (last batch)
                print("Epoch [{}/{}], loss_g: {:.4f}, loss_d: {:.4f}, real_score: {:.4f}, fake_score: {:.4f}".format(
                    epoch+1, epochs,
                    losses_g[-1], losses_d[-1], real_scores[-1], fake_scores[-1]))

                # Show generated images
                clear_output(wait=True)
                show_samples(fixed_latent)

    return losses_g, losses_d, real_scores, fake_scores

最后，我们将声明模型、优化器、损失并训练模型：

python 复制代码 
generator = Generator(latent_size).to(device)
discriminator = Discriminator().to(device)

models = {
    'generator': generator,
    'discriminator': discriminator
}

criterions = {
    "discriminator": nn.BCELoss(),
    "generator": nn.BCELoss()
}

lr = 0.0002
optimizers = {
        "discriminator": torch.optim.Adam(models["discriminator"].parameters(),
                                          lr=lr, betas=(0.5, 0.999)),
        "generator": torch.optim.Adam(models["generator"].parameters(),
                                      lr=lr, betas=(0.5, 0.999))
    }

losses_g, losses_d, real_scores, fake_scores = train(models, optimizers, criterions, 10, train_loader, val_loader)

输出：

让我们直观地看到网络训练期间生成器的损失和准确度指标的变化图：

python 复制代码 
plt.figure(figsize=(15, 6))
plt.plot(losses_d, '-')
plt.plot(losses_g, '-')
plt.xlabel('epoch')
plt.ylabel('loss')
plt.legend(['Discriminator', 'Generator'])
plt.title('Losses');

输出：

python 复制代码 
plt.figure(figsize=(15, 6))

plt.plot(real_scores, '-')
plt.plot(fake_scores, '-')
plt.xlabel('epoch')
plt.ylabel('score')
plt.legend(['Real', 'Fake'])
plt.title('Scores');

输出：

额外知识

相关推荐
满怀10152 分钟前
【Django全栈开发实战】从零构建企业级Web应用
前端·python·django·orm·web开发·前后端分离
夜幕龙3 分钟前
LeRobot 项目部署运行逻辑（七）—— ACT 在 Mobile ALOHA 训练与部署
人工智能·深度学习·机器学习
半路_出家ren17 分钟前
python处理异常，JSON
python·json·异常处理
朱剑君18 分钟前
第八天——贪心算法——队列重构问题
算法·贪心算法·重构
仙人掌_lz20 分钟前
深度理解用于多智能体强化学习的单调价值函数分解QMIX算法：基于python从零实现
python·算法·强化学习·rl·价值函数
小白学大数据25 分钟前
Python+Selenium爬虫：豆瓣登录反反爬策略解析
分布式·爬虫·python·selenium
未来之窗软件服务27 分钟前
人体肢体渲染-一步几个脚印从头设计数字生命——仙盟创梦IDE
开发语言·ide·人工智能·python·pygame·仙盟创梦ide
戌崂石34 分钟前
最优化方法Python计算：有约束优化应用——线性不可分问题支持向量机
python·机器学习·支持向量机·最优化方法
Echo``35 分钟前
40：相机与镜头选型
开发语言·人工智能·深度学习·计算机视觉·视觉检测
玉笥寻珍38 分钟前
Web安全渗透测试基础知识之内存动态分配异常篇
网络·python·安全·web安全·网络安全
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】03从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑04【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！05Coze扣子平台完整体验和实践（附国内和国际版对比）06DeepSeek各版本说明与优缺点分析07【解决】Android Gradle Sync 报错 Could not read workspace metadata08YOLOv5改进 | 添加CA注意力机制 + 增加预测层 + 更换损失函数之GIoU09苍穹外卖面试总结10yolov10来了！用yolov10训练自己的数据集（原理、训练、部署、应用）