昇思25天學習打卡營第16天 | DCGAN生成漫畫頭像

這兩天把minspore配置到我的電腦上了，然后運行就沒什么問題了?😊

今天學這個DCGAN生成漫畫頭像，我超級感興趣的嘞🦄🥰

GAN基礎原理

這部分原理介紹參考GAN圖像生成。

DCGAN原理

DCGAN（深度卷積對抗生成網絡，Deep Convolutional Generative Adversarial Networks）是GAN的直接擴展。不同之處在于，DCGAN會分別在判別器和生成器中使用卷積和轉置卷積層。

它最早由Radford等人在論文Unsupervised Representation Learning With Deep Convolutional Generative Adversarial Networks中進行描述。判別器由分層的卷積層、BatchNorm層和LeakyReLU激活層組成。輸入是3x64x64的圖像，輸出是該圖像為真圖像的概率。生成器則是由轉置卷積層、BatchNorm層和ReLU激活層組成。輸入是標準正態分布中提取出的隱向量𝑧𝑧，輸出是3x64x64的RGB圖像。

本教程將使用動漫頭像數據集來訓練一個生成式對抗網絡，接著使用該網絡生成動漫頭像圖片。

數據準備與處理

from download import downloadurl = "https://download.mindspore.cn/dataset/Faces/faces.zip"path = download(url, "./faces", kind="zip", replace=True)

數據處理

batch_size = 128          # 批量大小
image_size = 64           # 訓練圖像空間大小
nc = 3                    # 圖像彩色通道數
nz = 100                  # 隱向量的長度
ngf = 64                  # 特征圖在生成器中的大小
ndf = 64                  # 特征圖在判別器中的大小
num_epochs = 3           # 訓練周期數
lr = 0.0002               # 學習率
beta1 = 0.5               # Adam優化器的beta1超參數import numpy as np
import mindspore.dataset as ds
import mindspore.dataset.vision as visiondef create_dataset_imagenet(dataset_path):"""數據加載"""dataset = ds.ImageFolderDataset(dataset_path,num_parallel_workers=4,shuffle=True,decode=True)# 數據增強操作transforms = [vision.Resize(image_size),vision.CenterCrop(image_size),vision.HWC2CHW(),lambda x: ((x / 255).astype("float32"))]# 數據映射操作dataset = dataset.project('image')dataset = dataset.map(transforms, 'image')# 批量操作dataset = dataset.batch(batch_size)return datasetdataset = create_dataset_imagenet('./faces')import matplotlib.pyplot as pltdef plot_data(data):# 可視化部分訓練數據plt.figure(figsize=(10, 3), dpi=140)for i, image in enumerate(data[0][:30], 1):plt.subplot(3, 10, i)plt.axis("off")plt.imshow(image.transpose(1, 2, 0))plt.show()sample_data = next(dataset.create_tuple_iterator(output_numpy=True))
plot_data(sample_data)

構造網絡

當處理完數據后，就可以來進行網絡的搭建了。按照DCGAN論文中的描述，所有模型權重均應從mean為0，sigma為0.02的正態分布中隨機初始化。

生成器

生成器G的功能是將隱向量z映射到數據空間。由于數據是圖像，這一過程也會創建與真實圖像大小相同的 RGB 圖像。在實踐場景中，該功能是通過一系列Conv2dTranspose轉置卷積層來完成的，每個層都與BatchNorm2d層和ReLu激活層配對，輸出數據會經過tanh函數，使其返回[-1,1]的數據范圍內。

DCGAN論文生成圖像如下所示：

dcgangenerator

我們通過輸入部分中設置的nz、ngf和nc來影響代碼中的生成器結構。nz是隱向量z的長度，ngf與通過生成器傳播的特征圖的大小有關，nc是輸出圖像中的通道數。

以下是生成器的代碼實現：

import mindspore as ms
from mindspore import nn, ops
from mindspore.common.initializer import Normalweight_init = Normal(mean=0, sigma=0.02)
gamma_init = Normal(mean=1, sigma=0.02)class Generator(nn.Cell):"""DCGAN網絡生成器"""def __init__(self):super(Generator, self).__init__()self.generator = nn.SequentialCell(nn.Conv2dTranspose(nz, ngf * 8, 4, 1, 'valid', weight_init=weight_init),nn.BatchNorm2d(ngf * 8, gamma_init=gamma_init),nn.ReLU(),nn.Conv2dTranspose(ngf * 8, ngf * 4, 4, 2, 'pad', 1, weight_init=weight_init),nn.BatchNorm2d(ngf * 4, gamma_init=gamma_init),nn.ReLU(),nn.Conv2dTranspose(ngf * 4, ngf * 2, 4, 2, 'pad', 1, weight_init=weight_init),nn.BatchNorm2d(ngf * 2, gamma_init=gamma_init),nn.ReLU(),nn.Conv2dTranspose(ngf * 2, ngf, 4, 2, 'pad', 1, weight_init=weight_init),nn.BatchNorm2d(ngf, gamma_init=gamma_init),nn.ReLU(),nn.Conv2dTranspose(ngf, nc, 4, 2, 'pad', 1, weight_init=weight_init),nn.Tanh())def construct(self, x):return self.generator(x)generator = Generator()

判別器

如前所述，判別器D是一個二分類網絡模型，輸出判定該圖像為真實圖的概率。通過一系列的Conv2d、BatchNorm2d和LeakyReLU層對其進行處理，最后通過Sigmoid激活函數得到最終概率。

DCGAN論文提到，使用卷積而不是通過池化來進行下采樣是一個好方法，因為它可以讓網絡學習自己的池化特征。

判別器的代碼實現如下：

class Discriminator(nn.Cell):"""DCGAN網絡判別器"""def __init__(self):super(Discriminator, self).__init__()self.discriminator = nn.SequentialCell(nn.Conv2d(nc, ndf, 4, 2, 'pad', 1, weight_init=weight_init),nn.LeakyReLU(0.2),nn.Conv2d(ndf, ndf * 2, 4, 2, 'pad', 1, weight_init=weight_init),nn.BatchNorm2d(ngf * 2, gamma_init=gamma_init),nn.LeakyReLU(0.2),nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 'pad', 1, weight_init=weight_init),nn.BatchNorm2d(ngf * 4, gamma_init=gamma_init),nn.LeakyReLU(0.2),nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 'pad', 1, weight_init=weight_init),nn.BatchNorm2d(ngf * 8, gamma_init=gamma_init),nn.LeakyReLU(0.2),nn.Conv2d(ndf * 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()

模型訓練

損失函數

當定義了D和G后，接下來將使用MindSpore中定義的二進制交叉熵損失函數BCELoss。

優化器

這里設置了兩個單獨的優化器，一個用于D，另一個用于G。這兩個都是lr = 0.0002和beta1 = 0.5的Adam優化器。

訓練模型

訓練分為兩個主要部分：訓練判別器和訓練生成器。

訓練判別器

訓練判別器的目的是最大程度地提高判別圖像真偽的概率。按照Goodfellow的方法，是希望通過提高其隨機梯度來更新判別器，所以我們要最大化𝑙𝑜𝑔𝐷(𝑥)+𝑙𝑜𝑔(1?𝐷(𝐺(𝑧))𝑙𝑜𝑔𝐷(𝑥)+𝑙𝑜𝑔(1?𝐷(𝐺(𝑧))的值。
訓練生成器

如DCGAN論文所述，我們希望通過最小化𝑙𝑜𝑔(1?𝐷(𝐺(𝑧)))𝑙𝑜𝑔(1?𝐷(𝐺(𝑧)))來訓練生成器，以產生更好的虛假圖像。

在這兩個部分中，分別獲取訓練過程中的損失，并在每個周期結束時進行統計，將fixed_noise批量推送到生成器中，以直觀地跟蹤G的訓練進度。

下面實現模型訓練正向邏輯：

# 定義損失函數
adversarial_loss = nn.BCELoss(reduction='mean')# 為生成器和判別器設置優化器
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_G.update_parameters_name('optim_g.')
optimizer_D.update_parameters_name('optim_d.')def generator_forward(real_imgs, valid):# 將噪聲采樣為發生器的輸入z = ops.standard_normal((real_imgs.shape[0], nz, 1, 1))# 生成一批圖像gen_imgs = generator(z)# 損失衡量發生器繞過判別器的能力g_loss = adversarial_loss(discriminator(gen_imgs), valid)return g_loss, gen_imgsdef discriminator_forward(real_imgs, gen_imgs, valid, fake):# 衡量鑒別器從生成的樣本中對真實樣本進行分類的能力real_loss = adversarial_loss(discriminator(real_imgs), valid)fake_loss = adversarial_loss(discriminator(gen_imgs), fake)d_loss = (real_loss + fake_loss) / 2return d_lossgrad_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)@ms.jit
def train_step(imgs):valid = ops.ones((imgs.shape[0], 1), mindspore.float32)fake = ops.zeros((imgs.shape[0], 1), mindspore.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)return g_loss, d_loss, gen_imgsimport mindsporeG_losses = []
D_losses = []
image_list = []total = dataset.get_dataset_size()
for epoch in range(num_epochs):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, nz, 1, 1))img = generator(fixed_noise)image_list.append(img.transpose(0, 2, 3, 1).asnumpy())# 保存網絡模型參數為ckpt文件mindspore.save_checkpoint(generator, "./generator.ckpt")mindspore.save_checkpoint(discriminator, "./discriminator.ckpt")