生成对抗网络GAN与DCGAN的理解

2023年4月5日下午11:48 • GAN生成对抗网络

生成对抗网络GAN与DCGAN的理解

作者在进行GAN学习中遇到的问题汇总到下方，并进行解读讲解,下面提到的题目是李宏毅老师机器学习课程的作业6（GAN）

一.GAN

网络上有关GAN和DCGAN的讲解已经很多，在这里不再加以赘述，放几个我认为比较好的讲解
1.GAN概念理解
2.理解GAN网络基本原理
3.李宏毅机器学习课程
4.换个角度看GAN：另一种损失函数

二.DCGAN

1.从头开始GAN【论文】(二) —— DCGAN
2.PyTorch教程之DCGAN
3.pytorch官方DCGAN样例讲解

三.示例代码解读

3.1关于数据集的下载

官方的数据集需要FQ下载，在查找相关网址后，上网找到了数据集，并成功下载，如下是数据集链接：
提取码：ctgr

成功下载并解压，可以删除作业代码中的有关下载和解压的部分

可以打开我最下面放的文件，改变数据地址即可（main函数中的workspace_dir）

   You may replace the workspace directory if you want.
   workspace_dir = '.'
   Training progress bar
   !pip install -q qqdm
   !gdown --id 1IGrTr308mGAaCKotpkkm8wTKlWs9Jq-p --output "{workspace_dir}/crypko_data.zip"

3.2导入相关包和函数

  import random
  import torch
  import numpy as np
  import os
  import glob
  import torch.nn as nn
  import torch.nn.functional as F
  import torchvision
  import torchvision.transforms as transforms
  from torch import optim
  from torch.autograd import Variable
  from torch.utils.data import Dataset, DataLoader
  import matplotlib.pyplot as plt
  from qqdm.notebook import qqdm

如果没有qqdm或者matplotlib则需要pip或者conda下载（qqdm是进度条，在训练过程中可以显示训练进度）

3.3DateSet 数据预处理

Transfrom：

1.transforms.Compose()：将一系列的transforms有序组合，实现时按照这些方法依次对图像操作。

类似封装函数，依次执行

2.transforms.ToPILImage：将数据转换为PILImage。
3.transforms.Resize：图像变换
4.transforms.ToTensor：转为tensor，并归一化至[0-1]
5.transforms.Normalize：数据归一化处理

mean:各通道的均值
std：各通道的标准差

关于为什么要进行归一化处理可以参考transforms.Normalize（）

6.主函数进行数据加载：

  workspace_dir='D://机器学习//Jupyter//GAN学习//函数'
  dataset = get_dataset(os.path.join(workspace_dir, 'faces'))

3.4Model-模型的建立-DCGAN

3.4.1权重初始化

DCGAN指出，所有的权重都以均值为0，标准差为0.2的正态分布随机初始化。weights_init 函数读取一个已初始化的模型并重新初始化卷积层，转置卷积层，batch normalization 层。这个函数在模型初始化之后使用。

def weights_init(m):
    classname = m.__class__.__name__
    if classname.find('Conv') != -1:
        m.weight.data.normal_(0.0, 0.02)
    elif classname.find('BatchNorm') != -1:
        m.weight.data.normal_(1.0, 0.02)
        m.bias.data.fill_(0)

3.4.2Generator-生成器模型

生成器的目的是将输入向量z zz 映射到真的数据空间。这儿我们的数据为图片，意味着我们需要将输入向量z zz转换为 3x64x64的RGB图像。实际操作时，我们通过一系列的二维转置卷，每次转置卷积后跟一个二维的batch norm层和一个relu激活层。生成器的输出接入tanh函数以便满足输出范围为[−1,1]。值得一提的是，每个转置卷积后面跟一个 batch norm 层，是DCGAN论文的一个主要贡献。这些网络层有助于训练时的梯度计算。

下面为生成器模型分析

该函数由反卷积+batch norm+relu构成

反卷积参考这里

      def dconv_bn_relu(in_dim, out_dim):
            return nn.Sequential(
                nn.ConvTranspose2d(in_dim, out_dim, 5, 2,
                                   padding=2, output_padding=1, bias=False),
                nn.BatchNorm2d(out_dim),
                nn.ReLU()
            )

类似dconv_bn_relu，但特殊在l1为网络的第一层，输入输出和后面的l2不同(我其实觉得可以放到一起，但可能分开更加清除一些)

       self.l1 = nn.Sequential(
                  nn.Linear(in_dim, dim * 8 * 4 * 4, bias=False),
                  nn.BatchNorm1d(dim * 8 * 4 * 4),
                  nn.ReLU()
              )

实例化生成器并调用weights_init函数

       self.l2_5 = nn.Sequential(
                  dconv_bn_relu(dim * 8, dim * 4),
                  dconv_bn_relu(dim * 4, dim * 2),
                  dconv_bn_relu(dim * 2, dim),
                  nn.ConvTranspose2d(dim, 3, 5, 2, padding=2, output_padding=1),
                  nn.Tanh()
              )

构建cnn网络结构，tanh函数使输出在[-1,1]之间

      self.apply(weights_init)

整体模型合并

      def forward(self, x):
          y = self.l1(x)
          y = y.view(y.size(0), -1, 4, 4)
          y = self.l2_5(y)
          return y

主函数中生成实例，并输出网络结构

     netG=Generator(100)
      print(netG)

运行后得到网络结构

  (l1): Sequential(
    (0): Linear(in_features=100, out_features=8192, bias=False)
    (1): BatchNorm1d(8192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU()
  )
  (l2_5): Sequential(
    (0): Sequential(
      (0): ConvTranspose2d(512, 256, kernel_size=(5, 5), stride=(2, 2), padding=(2, 2), output_padding=(1, 1), bias=False)
      (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU()
    )
    (1): Sequential(
      (0): ConvTranspose2d(256, 128, kernel_size=(5, 5), stride=(2, 2), padding=(2, 2), output_padding=(1, 1), bias=False)
      (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU()
    )
    (2): Sequential(
      (0): ConvTranspose2d(128, 64, kernel_size=(5, 5), stride=(2, 2), padding=(2, 2), output_padding=(1, 1), bias=False)
      (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU()
    )
    (3): ConvTranspose2d(64, 3, kernel_size=(5, 5), stride=(2, 2), padding=(2, 2), output_padding=(1, 1))
    (4): Tanh()
  )
)

3.4.3 Discriminator-判别器模型

判别器的输入为3 *64 *64，输出为概率（分数），依次通过卷积层，BN层，LeakyReLU层，最后通过sigmoid函数输出得分

from torch import nn

from 函数.weights_inition import weights_init


class Discriminator(nn.Module):
    """
    Input shape: (N, 3, 64, 64)
    Output shape: (N, )
    """

    def __init__(self, in_dim, dim=64):
        super(Discriminator, self).__init__()

        def conv_bn_lrelu(in_dim, out_dim):
            return nn.Sequential(
                nn.Conv2d(in_dim, out_dim, 5, 2, 2),
                nn.BatchNorm2d(out_dim),
                nn.LeakyReLU(0.2),
            )

        """ Medium: Remove the last sigmoid layer for WGAN. """
        self.ls = nn.Sequential(
            nn.Conv2d(in_dim, dim, 5, 2, 2),
            nn.LeakyReLU(0.2),
            conv_bn_lrelu(dim, dim * 2),
            conv_bn_lrelu(dim * 2, dim * 4),
            conv_bn_lrelu(dim * 4, dim * 8),
            nn.Conv2d(dim * 8, 1, 4),
            nn.Sigmoid(),
        )
        self.apply(weights_init)

    def forward(self, x):
        y = self.ls(x)
        y = y.view(-1)
        return y

类似生成器，具体框架不再分开说明

生成实例，观察网络结构

Discriminator(
  (ls): Sequential(
    (0): Conv2d(3, 64, kernel_size=(5, 5), stride=(2, 2), padding=(2, 2))
    (1): LeakyReLU(negative_slope=0.2)
    (2): Sequential(
      (0): Conv2d(64, 128, kernel_size=(5, 5), stride=(2, 2), padding=(2, 2))
      (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): LeakyReLU(negative_slope=0.2)
    )
    (3): Sequential(
      (0): Conv2d(128, 256, kernel_size=(5, 5), stride=(2, 2), padding=(2, 2))
      (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): LeakyReLU(negative_slope=0.2)
    )
    (4): Sequential(
      (0): Conv2d(256, 512, kernel_size=(5, 5), stride=(2, 2), padding=(2, 2))
      (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): LeakyReLU(negative_slope=0.2)
    )
    (5): Conv2d(512, 1, kernel_size=(4, 4), stride=(1, 1))
    (6): Sigmoid()
  )
)

3.5Training-模型的训练-DCGAN

3.5.1 创建网络结构

  G = Generator(in_dim=z_dim).to(device)
  D = Discriminator(3).to(device)
  G.train()
  D.train()

  # Loss
  criterion = nn.BCELoss()


  # Optimizer
  opt_D = torch.optim.Adam(D.parameters(), lr=lr, betas=(0.5, 0.999))
  opt_G = torch.optim.Adam(G.parameters(), lr=lr, betas=(0.5, 0.999))

in_dim=z_dim=100,z的分布（高斯分布）深度为100
因为input的是图片，3channels，所以Discriminator(3)
如果模型中有BN层，需要在训练时添加model.train()，在测试时添加model.eval()。其中model.train()是保证BN层用每一批数据的均值和方差，而model.eval()是保证BN用全部训练数据的均值和方差。
损失函数使用二元交叉熵损失(BCELoss)
这里使用Adam优化器更新参数Adam+pytorch，学习率设置为0.0002 Betal=0.5。

3.5.2加载数据

Dataloader参考dataloader

  dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True, num_workers=2)

z为随机生成64*100的高斯分布数据（均值为0，方差为1）也叫噪声。
z为生成器的输入。

3.5.3 训练D(判别器)

z为随机生成64*100的高斯分布数据（均值为0，方差为1）也叫噪声。
z为生成器的输入。

      z = Variable(torch.randn(bs, z_dim)).to(device)

f_imgs大小为 64 *3 *64 *64(生成64张假图片)
将z直接传入G (),可以直接调用forward（）函数进行操作，参考forward。
下面展示forward（）函数的流程

      r_imgs = Variable(imgs).to(device)
      f_imgs = G(z)

进行标签定义，真实图片的label为1，生成的图片的label为0。

      r_label = torch.ones((bs)).to(device)
      f_label = torch.zeros((bs)).to(device)

把两种图片放入判别器，将r_imgs设置为detach(),意为参数不再更新（很好理解，因为图片的数据肯定不可以改变，只能改变网络的参数，所以就锁定了图片数据）。r_logit表示真实图片得分(越高越好)，f_logit表示假图片得分（越低越好）。

      r_logit = D(r_imgs.detach())
      f_logit = D(f_imgs.detach())

计算损失，就是将两种损失加起来除以二。

      r_loss = criterion(r_logit, r_label)
      f_loss = criterion(f_logit, f_label)
      loss_D = (r_loss + f_loss) / 2

module.zero_grad(），每一个batch的训练将参数的梯度清零。
对loss进行反向传播算法，.backward（）可以计算所有与loss_D有关的参数的梯度，参考backward。
optimizer.step()，进行参数更新(Adam)。

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

3.5.4 训练G(生成器)

z为随机生成64*100的高斯分布数据（均值为0，方差为1）也叫噪声。
z为生成器的输入。

   z = Variable(torch.randn(bs, z_dim)).to(device)

生成假图片，并计算得分（越高越好）。

   f_imgs = G(z)
   f_logit = D(f_imgs)
   loss_G = criterion(f_logit, r_label)

更新参数

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

3.6结果展示

生成最后的结果（测试图片），每一个epoch生成一张图片。

有关pytorch中dataloader，dataset以及数据显示的学习可以参考PyTorch深度学习快速入门教程（绝对通俗易懂！）【小土堆】

        G.eval()
        f_imgs_sample = (G(z_sample).data + 1) / 2.0
        filename = os.path.join(log_dir, f'Epoch_{epoch + 1:03d}.jpg')
        torchvision.utils.save_image(f_imgs_sample, filename, nrow=10)
        print(f' | Save some samples to {filename}.')

        # Show generated images in the jupyter notebook.
        grid_img = torchvision.utils.make_grid(f_imgs_sample.cpu(), nrow=10)
        plt.figure(figsize=(10, 10))
        plt.imshow(grid_img.permute(1, 2, 0))
        plt.show()
        G.train()

        if (e + 1) % 5 == 0 or e == 0:
            # Save the checkpoints.
            torch.save(G.state_dict(), os.path.join(ckpt_dir, 'G.pth'))
            torch.save(D.state_dict(), os.path.join(ckpt_dir, 'D.pth'))

下图分别是我设置epoch为5，bitch_size为10和64生成的测试图片
bitch_size=10

bitch_size=64

观察图片会有一些问题，比如面部不全，眼睛颜色不对或者人脸模糊等问题，转换GAN类型或者增加数据集等可能使结果更好。

3.7代码文件

李宏毅老师的作业文件是.ipynb文件，我把函数分开写进了PyCharm中，在使用时需要更改各个函数中
import的文件名，还有数据的地址（在main函数中）改为自己的地址
提取码:dkdd

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：生成对抗网络GAN与DCGAN的理解 - Python技术站

GAN生成对抗网络人工智能

0 0 打赏

微信扫一扫

支付宝扫一扫

[深度学习-原理]GAN(生成对抗网络)的简单介绍

上一篇 2023年4月5日下午11:48

生成对抗网络（GAN）入门（CS231n）

下一篇 2023年4月5日下午11:48

机器学习中常用评估指标

评估指标 Evaluation metrics 可以说明模型的性能，辨别模型的结果。我们建立一个模型后，计算指标，从指标获取反馈，再继续改进模型，直到达到理想的准确度。在预测之前检查模型的准确度至关重要，而不应该建立一个模型后，就直接将模型应用到看不到的数据上。今天先来简单介绍几种回归和分类常用的评估方法。回归均方误差：其中D为数据分布，p为概率…

机器学习 2023年4月11日
000
目标检测

目标检测之指尖检测—指尖检测的新方法几种

指尖检测根据应用可以分为单指尖检测和多指尖检测。下面是我在工作中想到的方法，希望对你有用或提供点儿灵感。单指尖检测新方法：重心距离法找到手的区域，我一般用肤色检测计算手的区域的重心在手的区域的边缘点集中寻找距离重心最远的点，该点即为指尖候选位置判断找到的点是否为指尖。判据：候选点到重心的距离大于边缘到重心平均距离的1.6倍，即为指尖；否则不是…

2023年4月8日
000
概念（机器学习）：有监督、无监督、半监督学习

来源：机器学习算法盘点 – ranjiewen – 博客园 http://www.cnblogs.com/ranjiewen/p/6235388.html 机器学习的算法很多。很多算法是一类算法，而有些算法又是从其他算法中延伸出来的。这里从两个方面来给大家介绍，第一个方面是学习的方式，第二个方面是算法的类似性。学习方式　　根据数据类型的不同，对…

机器学习 2023年4月11日
000
卷积神经网络

卷积神经网络对图片分类-下

接上篇：卷积神经网络对图片分类-中 9 ReLU(Rectified Linear Units) Layers 在每个卷积层之后，会马上进入一个激励层，调用一种激励函数来加入非线性因素，决绝线性不可分的问题。这里我们选择的激励函数方式叫做ReLU, 他的方程是这样f(x) = max(0, x)，就是把小于零的值都归为0，好处是可以是网络训练的更快，减少…

2023年4月8日
000
目标检测

动手学深度学习之目标检测基础

目标检测是CV的四大基本任务之一，也是现在CV最热门的技术，与技术落地息息相关。目标检测相比于分类与分割，它的损失函数要更难理解一点。目标检测与边界框目标检测应用的场景通常是一副图像里有很多要关注的目标，比如下图有猫和狗两个目标，我们要分别把它们的位置和大小框出来，这用到的框便叫边界框。目标检测是解决”在哪里有什么”的任务。锚框锚框（Anchor）是…

2023年4月8日
000
AI 音辨世界：艺术小白的我，靠这个AI模型，速识音乐流派选择音乐 ⛵

音乐领域，借助于歌曲相关信息，模型可以根据歌曲的音频和歌词特征，将歌曲精准进行流派分类。本文讲解如何基于机器学习完成对音乐的识别分类。 ? 作者：韩信子@ShowMeAI? 数据分析实战系列：https://www.showmeai.tech/tutorials/40? 机器学习实战系列：https://www.showmeai.tech/tutorials…

机器学习 2023年4月11日
000
卷积神经网络

图卷积网络-多标签分类

首先理解一些以下：二分类：每一张图像输出一个类别信息多类别分类：每一张图像输出一个类别信息多输出分类：每一张图像输出固定个类别的信息多标签分类：每一张图像输出类别的个数不固定，如下图所示：多标签分类的一个重要特点就是标签是具有关联的，比如在含有sky（天空）的图像中，极有可能含有cloud（云）、sunset（日落）等。早期进行多标签分类使用的…

2023年4月8日
000
Caffe

Caffe框架GPU与MLU计算结果不一致请问如何调试？

Caffe框架GPU与MLU计算结果不一致请问如何调试？某一检测模型移植到CambriconCaffe上时，发现无法检测出结果，于是将GPU和MLU的运行结果输出并保存后进行对比，发现二者计算结果不一致，如下图所示：第一张为GPU模式下，第二张为GPU模式，二者使用的输入和数据预处理方式均完全一样，该输出为网络第一层卷积的部分输出。用Cambricon…

2023年4月8日
000

生成对抗网络GAN与DCGAN的理解

一.GAN

二.DCGAN

三.示例代码解读

3.1关于数据集的下载

3.2导入相关包和函数

3.3DateSet 数据预处理

3.4Model-模型的建立-DCGAN

3.4.1权重初始化

3.4.2Generator-生成器模型

下面为生成器模型分析

3.4.3 Discriminator-判别器模型

3.5Training-模型的训练-DCGAN

3.5.1 创建网络结构

3.5.2加载数据

3.5.3 训练D(判别器)

3.5.4 训练G(生成器)

3.6结果展示

3.7代码文件

相关文章