深度学习：DCGAN

目录

什么是DCGAN

DCGAN与GAN的区别

DCGAN生成器

DCGAN判别器

基于MindSpore框架实现DCGAN

数据集：

变量定义：

数据预处理：

生成器：

 判别器：

损失函数与优化器

训练模型

 模型推理

---

什么是DCGAN

CDGAN（Deep Convolutional Generative Adversarial Networks），是GAN（Generative Adversarial Networks）的一种变体，它特别使用了卷积神经网络（CNNs）作为生成器和判别器的构建模块。

DCGAN使用全卷积网络结构代替传统的池化层和全连接层。在生成器中采用转置卷积（也称为分数步长卷积或反卷积）来逐步增加图像的空间维度。

在判别器中使用卷积层来逐步减少空间维度并提取特征。

ReLU激活函数用于生成器的所有层（除输出层使用Tanh激活函数外），LeakyReLU激活函数用于判别器的所有层。

DCGAN与GAN的区别

• 基础架构：传统GAN没有对生成器和判别器的具体结构做出严格规定；而DCGAN明确指定了使用深度卷积网络。
• 稳定性：由于采用了上述改进措施，DCGAN相比原始GAN在训练过程中表现得更为稳定。
• 应用领域：虽然两者都可以应用于多种类型的数据生成任务，但DCGAN因其特殊的网络结构，在处理图像数据方面尤为有效。

关于GAN网络，可参考：深度学习：GAN图像生成-CSDN博客

DCGAN生成器

按照DCGAN论文中的描述，所有模型权重均应从mean为0，sigma为0.02的正态分布中随机初始化。

生成器G的功能是将隐向量z映射到数据空间。由于数据是图像，这一过程也会创建与真实图像大小相同的 RGB 图像。在实践场景中，该功能是通过一系列Conv2dTranspose转置卷积层来完成的，每个层都与BatchNorm2d层和ReLu激活层配对，输出数据会经过tanh函数，使其返回[-1,1]的数据范围内。

DCGAN判别器

判别器D是一个二分类网络模型，输出判定该图像为真实图的概率。通过一系列的Conv2d、BatchNorm2d和LeakyReLU层对其进行处理，最后通过Sigmoid激活函数得到最终概率。

DCGAN论文提到，使用卷积而不是通过池化来进行下采样是一个好方法，因为它可以让网络学习自己的池化特征。

基于MindSpore框架实现DCGAN

数据集：

# 记载数据集
from download import download

url = "https://download.mindspore.cn/dataset/Faces/faces.zip"

path = download(url, "./faces", kind="zip", replace=True)

变量定义：

# 变量定义
batch_size = 128 # 批量大小
image_size = 64 # 训练图像的空间大小
num_channels = 3 # 彩色图片的通道数
latent_size = 100 # 输入生成器的隐向量长度
generator_feature_size = 64 # 特征图在生成器中的大小
discriminator_feature_size = 64 # 特征图在判别器中的大小
num_epochs = 10 # 训练轮次
lr = 0.0002 # 学习率
beta1 = 0.5 # Adam优化器的beta1超参数

数据预处理：

# 对数据进行预处理并增强
import numpy as np
import mindspore as ms
import mindspore.dataset as ds
import mindspore.dataset.vision as vision
import time

def create_dataset_imagenet(dataset_path):
    dataset = ds.ImageFolderDataset(
        dataset_path, # 指定数据集所在的文件夹路径
        num_parallel_workers=4, # 并行工作线程为4
        shuffle=True, # 打乱数据集
        decode=True # 解码图片
    )
    
    # 数据增持
    transforms = [
        vision.Resize(image_size), # 将图像大小调整到指定的image_size
        vision.CenterCrop(image_size),  # 从中心裁剪出指定大小的image_size的图像
        vision.HWC2CHW(), # 将图像的通道顺序从HWC（高宽通道）转换为CHW（通道高宽）
        lambda x:((x / 255).astype("float32"))  # 将像素值归一化到[0,1]区间，并转换为float32类型
    ]
    
    # 数据映射操作
    dataset = dataset.project("image")
    dataset = dataset.map(transforms, "image") # 对'image'列应用上面定义的transforms变换
    
    # 批量操作
    dataset = dataset.batch(batch_size)
    return dataset

dataset = create_dataset_imagenet('./faces')

 

生成器：

from mindspore import nn, ops
from mindspore.common.initializer import Normal
# 初始化权重
weight_init = Normal(mean=0, sigma=0.02)
gamma_init = Normal(mean=1, sigma=0.02)

class Generator(nn.Cell):
    def __init__(self):
        super(Generator, self).__init__()
        self.generator = nn.SequentialCell(
            # (in_channels, out_channels, kernel_size, stride, pad_mode, padding)
            # pad_mode='valid':不对输入进行填充，返回输出可能的最大长度。
            nn.Conv2dTranspose(latent_size, generator_feature_size * 8, 4, 1, 'valid', weight_init=weight_init),
            nn.BatchNorm2d(generator_feature_size * 8, gamma_init=gamma_init),
            nn.ReLU(),
            # pad_mode='pad':对输入填充指定的量。
            nn.Conv2dTranspose(generator_feature_size * 8, generator_feature_size * 4, 4, 2, 'pad', 1, weight_init=weight_init),
            nn.BatchNorm2d(generator_feature_size * 4, gamma_init=gamma_init),
            nn.ReLU(),
            nn.Conv2dTranspose(generator_feature_size * 4, generator_feature_size * 2, 4, 2, 'pad', 1, weight_init=weight_init),
            nn.BatchNorm2d(generator_feature_size * 2, gamma_init=gamma_init),
            nn.ReLU(),
            nn.Conv2dTranspose(generator_feature_size * 2, generator_feature_size, 4, 2, 'pad', 1, weight_init=weight_init),
            nn.BatchNorm2d(generator_feature_size, gamma_init=gamma_init),
            nn.ReLU(),
            nn.Conv2dTranspose(generator_feature_size, num_channels, 4, 2, 'pad', 1, weight_init=weight_init),
            nn.Tanh()
        )
        
    def construct(self, x):
        return self.generator(x)
    
generator = Generator()

 判别器：

# 判别器
class Discriminator(nn.Cell):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.discriminator = nn.SequentialCell(
            nn.Conv2d(num_channels, discriminator_feature_size, 4, 2, 'pad', 1, weight_init=weight_init),
            nn.LeakyReLU(0.2),
            nn.Conv2d(discriminator_feature_size, discriminator_feature_size * 2, 4, 2, 'pad', 1, weight_init=weight_init),
            # gamma_init: 参数的初始化方法
            nn.BatchNorm2d(discriminator_feature_size * 2, gamma_init=gamma_init),
            nn.LeakyReLU(0.2),
            nn.Conv2d(discriminator_feature_size * 2, discriminator_feature_size * 4, 4, 2, 'pad', 1, weight_init=weight_init),
            nn.BatchNorm2d(discriminator_feature_size * 4, gamma_init=gamma_init),
            nn.LeakyReLU(0.2),
            nn.Conv2d(discriminator_feature_size * 4, discriminator_feature_size * 8, 4, 2, 'pad', 1, weight_init=weight_init),
            nn.BatchNorm2d(discriminator_feature_size * 8, gamma_init=gamma_init),
            nn.LeakyReLU(0.2),
            nn.Conv2d(discriminator_feature_size * 8, 1, 4, 1, 'valid', weight_init=weight_init)
        )
        self.adv_layer = nn.Sigmoid()
    
    def construct(self, X):
        out = self.discriminator(X)
        out = out.reshape(out.shape[0], -1)
        return self.adv_layer(out)
    
discriminator = Discriminator()

损失函数与优化器

loss = nn.BCELoss(reduction='mean')

# beta1: 第一个动量矩阵的指数衰减率
optimizer_D = nn.Adam(discriminator.trainable_params(), learning_rate=lr, beta1=beta1)
optimizer_G = nn.Adam(generator.trainable_params(), learning_rate=lr, beta1=beta1)
'''
optimizer.update_parameters_name() 
方法用于更新优化器参数的名称前缀。
这通常在你想要为优化器中的参数添加一个特定的命名空间或前缀时使用，
这样可以更容易地管理和区分不同的优化器参数
'''
optimizer_G.update_parameters_name('optim_g.')
optimizer_D.update_parameters_name('optim_d.')

训练模型

# 生成器forward函数
def generator_forward(real_imgs, valid):
    # 这里使用标准正态分布来生成噪声z，其形状为(batch_size, latent_size, 1, 1)。
    z = ops.standard_normal((real_imgs.shape[0], latent_size, 1, 1))
    gen_imgs = generator(z)
    # valid是目标标签，通常是一批全1的张量，表示这些图像是真实的。
    # loss计算判别器输出与目标标签之间的差异，这个差异就是生成器试图最小化的损失。
    g_loss = loss(discriminator(gen_imgs), valid)
    return g_loss, gen_imgs

# 判别器forward函数
def discriminator_forward(real_imgs, gen_imgs, valid, fake):
    real_loss = loss(discriminator(real_imgs), valid)
    fake_loss = loss(discriminator(gen_imgs), fake)
    d_loss = (real_loss + fake_loss) / 2
    return d_loss

# 计算梯度
'''
has_aux (bool) - 是否返回辅助参数的标志。
若为 True ， fn 输出数量必须超过一个，其中只有 fn 第一个输出参与求导，
其他输出值将直接返回。
'''
grad_generator_fn = ms.value_and_grad(generator_forward, None,
                                      optimizer_G.parameters,
                                      has_aux=True)

grad_discriminator_fn = ms.value_and_grad(discriminator_forward, None,
                                          optimizer_D.parameters)

def train_step(imgs):
    # 为真实的图像创建全1的有效标签
    valid = ops.ones((imgs.shape[0], 1), ms.float32)
    # 为假的图像创建全0的无效标签
    fake = ops.zeros((imgs.shape[0], 1), ms.float32)
    # 训练生成器
    (g_loss, gen_imgs), g_grads = grad_generator_fn(imgs, valid)
    optimizer_G(g_grads)
    # 训练判别器
    d_loss, d_grads = grad_discriminator_fn(imgs, gen_imgs, valid, fake)
    optimizer_D(d_grads)
    # 返回loss值和生成结果
    return g_loss, d_loss, gen_imgs

# 生成器损失集合
G_losses = []
# 判别器损失集合
D_losses = []
# 生成图像集合
image_list = []

total = dataset.get_dataset_size()

for epoch in range(num_epochs):
    start = time.time()
    # 没轮训练前，将模型设为训练状态
    generator.set_train()
    discriminator.set_train()
    for i, (imgs, ) in enumerate(dataset.create_tuple_iterator()):
        g_loss, d_loss, gen_imgs = train_step(imgs)
        if i % 100 == 0 or i == total - 1:
            # 输出训练记录
            print('[%2d/%d][%3d/%d]   Loss_D:%7.4f  Loss_G:%7.4f' % (
                epoch + 1, num_epochs, i + 1, total, d_loss.asnumpy(), g_loss.asnumpy()))
        D_losses.append(d_loss.asnumpy())
        G_losses.append(g_loss.asnumpy())
    
    # 每个epoch结束后，使用生成器生成一组图片
    generator.set_train(False)
    fixed_noise = ops.standard_normal((batch_size, latent_size, 1, 1))
    img = generator(fixed_noise)
    image_list.append(img.transpose(0, 2, 3, 1).asnumpy())
    
    # 保存网络模型参数为ckpt文件
    ms.save_checkpoint(generator, "./generator.ckpt")
    ms.save_checkpoint(discriminator, "./discriminator.ckpt")
    end = time.time()
    print('time:',(start-end))

 模型推理

# 模型推理
ms.load_checkpoint("./generator.ckpt", generator)

# 测试噪音数据
fixed_noise = ops.standard_normal((batch_size, latent_size, 1, 1))
img64 = generator(fixed_noise).transpose(0, 2, 3, 1).asnumpy()

fig = plt.figure(figsize=(8, 3), dpi=120)
images = []
for i in range(3):
    images.append(np.concatenate((img64[i * 8:(i + 1) * 8]), axis=1))
img = np.clip(np.concatenate((images[:]), axis=0), 0, 1)
plt.axis("off")
plt.imshow(img)
plt.show()