{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 深度卷积对抗生成网络\n",
    "\n",
    "[![](https://gitee.com/mindspore/docs/raw/r1.3/resource/_static/logo_source.png)](https://gitee.com/mindspore/docs/blob/r1.3/tutorials/source_zh_cn/intermediate/image_and_video/dcgan.ipynb) [![](https://gitee.com/mindspore/docs/raw/r1.3/resource/_static/logo_notebook.png)](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/r1.3/tutorials/zh_cn/mindspore_dcgan.ipynb) [![](https://gitee.com/mindspore/docs/raw/r1.3/resource/_static/logo_modelarts.png)](https://authoring-modelarts-cnnorth4.huaweicloud.com/console/lab?share-url-b64=aHR0cHM6Ly9taW5kc3BvcmUtd2Vic2l0ZS5vYnMuY24tbm9ydGgtNC5teWh1YXdlaWNsb3VkLmNvbS9ub3RlYm9vay9tb2RlbGFydHMvcXVpY2tfc3RhcnQvbWluZHNwb3JlX2RjZ2FuLmlweW5i&imageid=59a6e9f5-93c0-44dd-85b0-82f390c5d53b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 概述\n",
    "\n",
    "### GAN（生成对抗网络）\n",
    "\n",
    "生成对抗网络（GAN, Generative Adversarial Networks ）是一种深度学习模型，是近年来复杂分布上无监督学习最具前景的方法之一。最初，GAN由Ian Goodfellow 于2014年发明，并在论文[Generative Adversarial Nets](https://papers.nips.cc/paper/5423-generative-adversarial-nets.pdf)中首次进行了描述。GAN由两个不同的模型组成：*生成器*和*判别器*。生成器的任务是生成看起来像训练图像的“假”图像。判别器需要判断从生成器输出的图像是真实的训练图像还是生成的假图像。在训练过程中，生成器会不断尝试通过生成更好的假图像来骗过判别器，而判别器在这过程中也会逐步提升判别能力。这种博弈的平衡点是，当生成器生成的假图像看起来像训练数据时，判别器拥有50%的真假判断置信度。\n",
    "\n",
    "> 本篇基于MindSpore v1.3.0，CPU/GPU/Ascend环境运行。\n",
    "\n",
    "在教程开始前，首先定义一些在整个过程中需要用到的符号：\n",
    "\n",
    "- $x$：代表图像的数据；\n",
    "- $D(x)$：判别器网络，给出图像判定为真实图像的概率，其中$x$来自于训练数据而非生成器；\n",
    "由于我们在判别过程中需要处理图像，因此要为$D(x)$提供CHW格式且大小为`3x64x64`的图像。当$x$来自训练数据时，$D(x)$数值应该为高，而当$x$来自生成器时，$D(x)$数值应该为低。 因此$D(x)$也可以被认为是传统的二分类器；\n",
    "\n",
    "接下来我们来定义生成器的表示方法：\n",
    "\n",
    "- $z$：标准正态分布中提取出的隐向量；\n",
    "- $G(z)$：表示将隐向量$z$映射到数据空间的生成器函数；\n",
    "\n",
    "函数$G(z)$的目标是将一个随机高斯噪声$z$通过一个生成网络生成一个和真实数据分布$pdata(x)$差不多的数据分布，其中$θ$是网络参数，我们希望找到$θ$使得$pG(x;θ)$和$pdata(x)$尽可能的接近。\n",
    "\n",
    "- $D(G(z))$是生成器$G$生成的假图像被判定为真实图像的概率；\n",
    "\n",
    "如[Goodfellow 的论文](https://papers.nips.cc/paper/5423-generative-adversarial-nets.pdf)中所述，`D`和`G`在进行一场博弈，`D`想要最大程度的正确分类真图像与假图像，也就是参数$log D(x)$；而`G`试图欺骗`D`来最小化假图像被识别到的概率，也就是参数$log(1−D(G(z)))$。GAN的损失函数为\n",
    "\n",
    "$$\\min_{G}\\max_{D}V(D,G)=E_{x\\sim_Pdata(x)}[log(D(x))]+E_{z\\sim_Pz(z)}[log(1-D(G(z)))]$$\n",
    "\n",
    "从理论上讲，此博弈游戏的平衡点是$pG(x;θ) = pdata(x)$，此时判别器会随机猜测输入是真图像还是假图像。然而，GAN的收敛可行性仍在研究当中，在实际场景中模型并不会被训练到这一步。\n",
    "\n",
    "### DCGAN（深度卷积对抗生成网络）\n",
    "\n",
    "DCGAN是上述GAN的直接扩展。不同之处在于，DCGAN会分别在判别器和生成器中使用卷积和卷积转置层。它最早由Radford等人在论文[ Unsupervised Representation Learning With Deep Convolutional Generative Adversarial Networks](https://arxiv.org/pdf/1511.06434.pdf)中进行描述。判别器由分层的卷积层、BatchNorm层和LeakyReLU激活层组成。输入是3x64x64的图像，输出是该图像为真图像的概率。生成器则是由转置卷积层、BatchNorm层和ReLU激活层组成。输入是标准正态分布中提取出的隐向量$z$，输出是3x64x64的RGB图像。在下面的教程中，提供了有关如何设置优化器、如何计算损失函数以及如何初始化模型权重的说明。\n",
    "\n",
    "本教程将使用真实名人的照片来训练一个生成对抗网络（GAN），接着产生虚假名人图片。\n",
    "\n",
    "为了节省运行时间，建议用户使用GPU/Ascend来运行本实验。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 准备环节"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 导入模块"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import mindspore.dataset as ds\n",
    "import mindspore.dataset.vision.c_transforms as vision\n",
    "from mindspore.common.initializer import Initializer\n",
    "from mindspore import nn, ops, Tensor, context\n",
    "from mindspore import dtype as mstype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 配置环境"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "本教程我们在Ascend环境下，使用图模式运行实验。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "context.set_context(mode=context.GRAPH_MODE, device_target=\"Ascend\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 准备数据"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在本教程中，我们将使用[Celeb-A Faces 数据集](http://mmlab.ie.cuhk.edu.hk/projects/CelebA.html)，该数据集为人脸属性数据集，其包含10,177个名人身份的202,599张人脸图片。官网提供了多个下载链接，我们选择`Align&Cropped Images`下的`img_align_celeba.zip`，是202,599张经过人脸对齐和裁剪了的图像。因数据集较大，本教程为了节省下载和训练时间，所以采用了部分的数据集。为了完整流畅地运行程序，需要在当前路径下创建一个`data`目录，并在`data`目录下创建一个名为`celeba`的目录，并将压缩文件解压缩到该目录中。最后，将此教程的`dataroot`输入设置为刚创建的`celeba`目录。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在Jupyter Notebook中执行如下命令下载数据集。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "!mkdir -p ./data/celeba \n",
    "!wget -NP ./data/celeba https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/intermediate/img_align_celeba.rar\n",
    "!unrar x ./data/celeba/img_align_celeba.rar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "目录结构如下："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```py\n",
    "./data/celeba\n",
    "    -> img_align_celeba\n",
    "        -> 188242.jpg\n",
    "        -> 173822.jpg\n",
    "        -> 284702.jpg\n",
    "        -> 537394.jpg\n",
    "           ...\n",
    "\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据处理"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "首先为执行过程定义一些输入：\n",
    "\n",
    "- `dataroot`：数据集文件夹根目录；\n",
    "- `workers`：加载数据的线程数；\n",
    "- `batch_size`：训练中使用的批量大小，DCGAN论文使用的批量大小为128；\n",
    "- `image_size`：训练图像的大小，此实现默认为`64x64`，如果需要其他尺寸，则必须同时更改`D`和`G`的结构；\n",
    "- `nc`：输入图像中的彩色通道数，因为此次是彩色图像所以设为3；\n",
    "- `nz`：隐向量的长度；\n",
    "- `ngf`：设置通过生成器的特征图的深度；\n",
    "- `ndf`：设置通过判别器传播的特征图的深度；\n",
    "- `num_epochs`：要运行的训练周期数，训练更长的时间可能会导致更好的结果，但也会花费更长的时间；\n",
    "- `lr`：训练的学习率，如DCGAN论文中所述，此数字应为0.0001；\n",
    "- `beta1`：Adam优化器的`beta1`超参数。如DCGAN论文所述，该数字应为0.5；\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 数据集根目录\n",
    "dataroot = \"./data/celeba\"\n",
    "\n",
    "# 载入数据线程数\n",
    "workers = 4\n",
    "\n",
    "# 批量大小\n",
    "batch_size = 128\n",
    "\n",
    "# 训练图像空间大小，所有图像都将调整为该大小\n",
    "image_size = 64\n",
    "\n",
    "# 图像彩色通道数，对于彩色图像为3\n",
    "nc = 3\n",
    "\n",
    "# 隐向量的长度\n",
    "nz = 100\n",
    "\n",
    "# 特征图在生成器中的大小\n",
    "ngf = 64\n",
    "\n",
    "# 特征图在判别器中的大小\n",
    "ndf = 64\n",
    "\n",
    "# 训练周期数\n",
    "num_epochs = 10\n",
    "\n",
    "# 学习率\n",
    "lr = 0.0001\n",
    "\n",
    "# Beta1 超参数\n",
    "beta1 = 0.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 定义`create_dataset_imagenet`函数对数据进行处理和增强操作。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_dataset_imagenet(dataset_path, num_parallel_workers=None):\n",
    "    # 数据加载\n",
    "    data_set = ds.ImageFolderDataset(dataset_path, num_parallel_workers=num_parallel_workers, shuffle=True)\n",
    "\n",
    "    # 数据增强操作\n",
    "    transform_img = [\n",
    "        vision.Decode(),\n",
    "        vision.Resize(image_size),\n",
    "        vision.CenterCrop(image_size),\n",
    "        vision.HWC2CHW()\n",
    "    ]\n",
    "\n",
    "    # 数据映射操作\n",
    "    data_set = data_set.map(input_columns=\"image\", num_parallel_workers=num_parallel_workers, operations=transform_img,\n",
    "                            output_columns=\"image\")\n",
    "    data_set = data_set.map(input_columns=\"image\", num_parallel_workers=num_parallel_workers,\n",
    "                            operations=lambda x: ((x - 255) / 255).astype(\"float32\"))\n",
    "    data_set = data_set.map(\n",
    "        input_columns=\"image\",\n",
    "        operations=lambda x: (\n",
    "            x,\n",
    "            np.random.normal(size=(nz, 1, 1)).astype(\"float32\")\n",
    "        ),\n",
    "        output_columns=[\"image\", \"latent_code\"],\n",
    "        column_order=[\"image\", \"latent_code\"],\n",
    "        num_parallel_workers=num_parallel_workers\n",
    "    )\n",
    "    \n",
    "    # 批量操作\n",
    "    data_set = data_set.batch(batch_size)\n",
    "    \n",
    "    return data_set\n",
    "\n",
    "# 获取处理后的数据集\n",
    "data = create_dataset_imagenet(dataroot, num_parallel_workers=workers)\n",
    "\n",
    "# 获取数据集大小\n",
    "size = data.get_dataset_size()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 通过`create_dict_iterator`函数将数据转换成字典迭代器，然后使用`matplotlib`模块可视化部分训练数据。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 36 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "data_iter = next(data.create_dict_iterator(output_numpy=True, num_epochs=num_epochs))\n",
    "images = data_iter['image']\n",
    "count = 1\n",
    "\n",
    "# 可视化36张图片\n",
    "for i in images[:36]:\n",
    "    plt.subplot(6, 6, count)\n",
    "    plt.imshow(i.transpose(1, 2, 0))\n",
    "    plt.axis(\"off\")\n",
    "    plt.xticks([])\n",
    "    count += 1\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 创建网络\n",
    "\n",
    "当处理完数据后，就可以来进行网络的搭建了。网络搭建将以权重初始化策略为起点，逐一详细讨论生成器、判别器和损失函数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 权重初始化\n",
    "\n",
    "教程遵循DCGAN论文中的内容，所有模型权重均应从`mean`为0，`sigma`为0.02的正态分布中随机初始化。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _assignment(arr, num):\n",
    "    if arr.shape == ():\n",
    "        arr = arr.reshape((1))\n",
    "        arr[:] = num\n",
    "        arr = arr.reshape(())\n",
    "    else:\n",
    "        if isinstance(num, np.ndarray):\n",
    "            arr[:] = num[:]\n",
    "        else:\n",
    "            arr[:] = num\n",
    "    return arr\n",
    "\n",
    "class Normal(Initializer):\n",
    "    \"\"\"将模型权重从均值为0，标准差为0.02的正态分布中随机初始化\"\"\"\n",
    "    def __init__(self, mean=0.0, sigma=0.02):\n",
    "        super(Normal, self).__init__()\n",
    "        self.sigma = sigma\n",
    "        self.mean = mean\n",
    "        \n",
    "    def _initialize(self, arr):\n",
    "        np.random.seed(999)\n",
    "        arr_normal = np.random.normal(self.mean, self.sigma, arr.shape)\n",
    "        _assignment(arr, arr_normal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 生成器\n",
    "\n",
    "生成器`G`的功能是将隐向量`z`映射到数据空间。由于数据是图像，这一过程也会创建与真实图像大小相同的 RGB 图像。在实践场景中，该功能是通过一系列`Conv2dTranspose`转置卷积层来完成的，每个层都与`BatchNorm2d`层和`ReLu`激活层配对，输出数据会经过`tanh`函数，使其返回`[-1,1]`的数据范围内。\n",
    "\n",
    "DCGAN论文生成图像如下所示。\n",
    "\n",
    "![dcgangenerator](images/dcgan.png)\n",
    "\n",
    "> 图片来源 https://arxiv.org/pdf/1511.06434.pdf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们通过输入部分中设置的`nz`、`ngf`和`nc`来影响代码中的生成器结构。`nz`是隐向量`z`的长度，`ngf`与通过生成器传播的特征图的大小有关，`nc`是输出图像中的通道数。\n",
    "\n",
    "以下是生成器的代码实现："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convt(in_channels, out_channels, kernel_size, stride=1, padding=0, pad_mode=\"pad\"):\n",
    "    \"\"\"定义转置卷积层\"\"\"\n",
    "    weight_init = Normal(mean=0, sigma=0.02)\n",
    "    return nn.Conv2dTranspose(in_channels, out_channels,\n",
    "                              kernel_size=kernel_size, stride=stride, padding=padding,\n",
    "                              weight_init=weight_init, has_bias=False, pad_mode=pad_mode)\n",
    "\n",
    "\n",
    "def bn(num_features):\n",
    "    \"\"\"定义BatchNorm2d层\"\"\"\n",
    "    gamma_init = Normal(mean=1, sigma=0.02)\n",
    "    return nn.BatchNorm2d(num_features=num_features, gamma_init=gamma_init)\n",
    "\n",
    "\n",
    "class Generator(nn.Cell):\n",
    "    \"\"\"DCGAN网络生成器\"\"\"\n",
    "    def __init__(self):\n",
    "        super(Generator, self).__init__()\n",
    "        self.generator = nn.SequentialCell()\n",
    "        self.generator.append(convt(nz, ngf * 8, 4, 1, 0))\n",
    "        self.generator.append(bn(ngf * 8))\n",
    "        self.generator.append(nn.ReLU())\n",
    "        self.generator.append(convt(ngf * 8, ngf * 4, 4, 2, 1))\n",
    "        self.generator.append(bn(ngf * 4))\n",
    "        self.generator.append(nn.ReLU())\n",
    "        self.generator.append(convt(ngf * 4, ngf * 2, 4, 2, 1))\n",
    "        self.generator.append(bn(ngf * 2))\n",
    "        self.generator.append(nn.ReLU())\n",
    "        self.generator.append(convt(ngf * 2, ngf, 4, 2, 1))\n",
    "        self.generator.append(bn(ngf))\n",
    "        self.generator.append(nn.ReLU())\n",
    "        self.generator.append(convt(ngf, nc, 4, 2, 1))\n",
    "        self.generator.append(nn.Tanh())\n",
    "\n",
    "    def construct(self, x):\n",
    "        return self.generator(x)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "实例化生成器，并打印出生成器的结构。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generator<\n",
      "  (generator): SequentialCell<\n",
      "    (0): Conv2dTranspose<input_channels=100, output_channels=512, kernel_size=(4, 4),stride=(1, 1),  pad_mode=pad, padding=0, dilation=(1, 1), group=1, has_bias=False,weight_init=<__main__.Normal object at 0x7fdaf3c14b50>, bias_init=zeros>\n",
      "    (1): BatchNorm2d<num_features=512, eps=1e-05, momentum=0.09999999999999998, gamma=Parameter (name=1.gamma, shape=(512,), dtype=Float32, requires_grad=True), beta=Parameter (name=1.beta, shape=(512,), dtype=Float32, requires_grad=True), moving_mean=Parameter (name=1.moving_mean, shape=(512,), dtype=Float32, requires_grad=False), moving_variance=Parameter (name=1.moving_variance, shape=(512,), dtype=Float32, requires_grad=False)>\n",
      "    (2): ReLU<>\n",
      "    (3): Conv2dTranspose<input_channels=512, output_channels=256, kernel_size=(4, 4),stride=(2, 2),  pad_mode=pad, padding=1, dilation=(1, 1), group=1, has_bias=False,weight_init=<__main__.Normal object at 0x7fdaf3bf8d90>, bias_init=zeros>\n",
      "    (4): BatchNorm2d<num_features=256, eps=1e-05, momentum=0.09999999999999998, gamma=Parameter (name=4.gamma, shape=(256,), dtype=Float32, requires_grad=True), beta=Parameter (name=4.beta, shape=(256,), dtype=Float32, requires_grad=True), moving_mean=Parameter (name=4.moving_mean, shape=(256,), dtype=Float32, requires_grad=False), moving_variance=Parameter (name=4.moving_variance, shape=(256,), dtype=Float32, requires_grad=False)>\n",
      "    (5): ReLU<>\n",
      "    (6): Conv2dTranspose<input_channels=256, output_channels=128, kernel_size=(4, 4),stride=(2, 2),  pad_mode=pad, padding=1, dilation=(1, 1), group=1, has_bias=False,weight_init=<__main__.Normal object at 0x7fdaf18340d0>, bias_init=zeros>\n",
      "    (7): BatchNorm2d<num_features=128, eps=1e-05, momentum=0.09999999999999998, gamma=Parameter (name=7.gamma, shape=(128,), dtype=Float32, requires_grad=True), beta=Parameter (name=7.beta, shape=(128,), dtype=Float32, requires_grad=True), moving_mean=Parameter (name=7.moving_mean, shape=(128,), dtype=Float32, requires_grad=False), moving_variance=Parameter (name=7.moving_variance, shape=(128,), dtype=Float32, requires_grad=False)>\n",
      "    (8): ReLU<>\n",
      "    (9): Conv2dTranspose<input_channels=128, output_channels=64, kernel_size=(4, 4),stride=(2, 2),  pad_mode=pad, padding=1, dilation=(1, 1), group=1, has_bias=False,weight_init=<__main__.Normal object at 0x7fdaf1844450>, bias_init=zeros>\n",
      "    (10): BatchNorm2d<num_features=64, eps=1e-05, momentum=0.09999999999999998, gamma=Parameter (name=10.gamma, shape=(64,), dtype=Float32, requires_grad=True), beta=Parameter (name=10.beta, shape=(64,), dtype=Float32, requires_grad=True), moving_mean=Parameter (name=10.moving_mean, shape=(64,), dtype=Float32, requires_grad=False), moving_variance=Parameter (name=10.moving_variance, shape=(64,), dtype=Float32, requires_grad=False)>\n",
      "    (11): ReLU<>\n",
      "    (12): Conv2dTranspose<input_channels=64, output_channels=3, kernel_size=(4, 4),stride=(2, 2),  pad_mode=pad, padding=1, dilation=(1, 1), group=1, has_bias=False,weight_init=<__main__.Normal object at 0x7fdaf1844810>, bias_init=zeros>\n",
      "    (13): Tanh<>\n",
      "    >\n",
      "  >\n"
     ]
    }
   ],
   "source": [
    "netG = Generator()\n",
    "print(netG)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 判别器\n",
    "\n",
    "如前所述，判别器`D`是一个二分类网络模型，输出判定该图像为真实图的概率。通过一系列的`Conv2d`、`BatchNorm2d`和`LeakyReLU`层对其进行处理，最后通过`Sigmoid`激活函数得到最终概率。\n",
    "\n",
    "DCGAN论文提到，使用卷积而不是通过池化来进行下采样是一个好习惯，因为它可以让网络学习自己的池化特征。\n",
    "\n",
    "判别器的代码实现如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def conv(in_channels, out_channels, kernel_size, stride=1, padding=0, pad_mode=\"pad\"):\n",
    "    '''定义卷积层'''\n",
    "    weight_init = Normal(mean=0, sigma=0.02)\n",
    "    return nn.Conv2d(in_channels, out_channels,\n",
    "                     kernel_size=kernel_size, stride=stride, padding=padding,\n",
    "                     weight_init=weight_init, has_bias=False, pad_mode=pad_mode)\n",
    "\n",
    "class Discriminator(nn.Cell):\n",
    "    \"\"\"\n",
    "    DCGAN网络判别器\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self):\n",
    "        super(Discriminator, self).__init__()\n",
    "        self.discriminator = nn.SequentialCell()\n",
    "        self.discriminator.append(conv(nc, ndf, 4, 2, 1))\n",
    "        self.discriminator.append(nn.LeakyReLU(0.2))\n",
    "        self.discriminator.append(conv(ndf, ndf * 2, 4, 2, 1))\n",
    "        self.discriminator.append(bn(ndf * 2))\n",
    "        self.discriminator.append(nn.LeakyReLU(0.2))\n",
    "        self.discriminator.append(conv(ndf * 2, ndf * 4, 4, 2, 1))\n",
    "        self.discriminator.append(bn(ndf * 4))\n",
    "        self.discriminator.append(nn.LeakyReLU(0.2))\n",
    "        self.discriminator.append(conv(ndf * 4, ndf * 8, 4, 2, 1))\n",
    "        self.discriminator.append(bn(ndf * 8))\n",
    "        self.discriminator.append(nn.LeakyReLU(0.2))\n",
    "        self.discriminator.append(conv(ndf * 8, 1, 4, 1))\n",
    "        self.discriminator.append(nn.Sigmoid())\n",
    "\n",
    "    def construct(self, x):\n",
    "        return self.discriminator(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "实例化判别器，并打印出判别器的结构。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Discriminator<\n",
      "  (discriminator): SequentialCell<\n",
      "    (0): Conv2d<input_channels=3, output_channels=64, kernel_size=(4, 4),stride=(2, 2),  pad_mode=pad, padding=1, dilation=(1, 1), group=1, has_bias=Falseweight_init=<__main__.Normal object at 0x7fdaf17989d0>, bias_init=zeros, format=NCHW>\n",
      "    (1): LeakyReLU<>\n",
      "    (2): Conv2d<input_channels=64, output_channels=128, kernel_size=(4, 4),stride=(2, 2),  pad_mode=pad, padding=1, dilation=(1, 1), group=1, has_bias=Falseweight_init=<__main__.Normal object at 0x7fdaf1798b90>, bias_init=zeros, format=NCHW>\n",
      "    (3): BatchNorm2d<num_features=128, eps=1e-05, momentum=0.09999999999999998, gamma=Parameter (name=3.gamma, shape=(128,), dtype=Float32, requires_grad=True), beta=Parameter (name=3.beta, shape=(128,), dtype=Float32, requires_grad=True), moving_mean=Parameter (name=3.moving_mean, shape=(128,), dtype=Float32, requires_grad=False), moving_variance=Parameter (name=3.moving_variance, shape=(128,), dtype=Float32, requires_grad=False)>\n",
      "    (4): LeakyReLU<>\n",
      "    (5): Conv2d<input_channels=128, output_channels=256, kernel_size=(4, 4),stride=(2, 2),  pad_mode=pad, padding=1, dilation=(1, 1), group=1, has_bias=Falseweight_init=<__main__.Normal object at 0x7fdaf18ba350>, bias_init=zeros, format=NCHW>\n",
      "    (6): BatchNorm2d<num_features=256, eps=1e-05, momentum=0.09999999999999998, gamma=Parameter (name=6.gamma, shape=(256,), dtype=Float32, requires_grad=True), beta=Parameter (name=6.beta, shape=(256,), dtype=Float32, requires_grad=True), moving_mean=Parameter (name=6.moving_mean, shape=(256,), dtype=Float32, requires_grad=False), moving_variance=Parameter (name=6.moving_variance, shape=(256,), dtype=Float32, requires_grad=False)>\n",
      "    (7): LeakyReLU<>\n",
      "    (8): Conv2d<input_channels=256, output_channels=512, kernel_size=(4, 4),stride=(2, 2),  pad_mode=pad, padding=1, dilation=(1, 1), group=1, has_bias=Falseweight_init=<__main__.Normal object at 0x7fdaf1798c10>, bias_init=zeros, format=NCHW>\n",
      "    (9): BatchNorm2d<num_features=512, eps=1e-05, momentum=0.09999999999999998, gamma=Parameter (name=9.gamma, shape=(512,), dtype=Float32, requires_grad=True), beta=Parameter (name=9.beta, shape=(512,), dtype=Float32, requires_grad=True), moving_mean=Parameter (name=9.moving_mean, shape=(512,), dtype=Float32, requires_grad=False), moving_variance=Parameter (name=9.moving_variance, shape=(512,), dtype=Float32, requires_grad=False)>\n",
      "    (10): LeakyReLU<>\n",
      "    (11): Conv2d<input_channels=512, output_channels=1, kernel_size=(4, 4),stride=(1, 1),  pad_mode=pad, padding=0, dilation=(1, 1), group=1, has_bias=Falseweight_init=<__main__.Normal object at 0x7fdaf1798bd0>, bias_init=zeros, format=NCHW>\n",
      "    (12): Sigmoid<>\n",
      "    >\n",
      "  >\n"
     ]
    }
   ],
   "source": [
    "netD = Discriminator()\n",
    "print(netD)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 连接网络和损失函数\n",
    "\n",
    "MindSpore将损失函数、优化器等操作都封装到了Cell中，因为GAN结构上的特殊性，其损失是判别器和生成器的多输出形式，这就导致它和一般的分类网络不同。所以我们需要自定义`WithLossCell`类，将网络和Loss连接起来。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class WithLossCellG(nn.Cell):\n",
    "    \"\"\"连接生成器和损失\"\"\"\n",
    "    def __init__(self, netD, netG, loss_fn):\n",
    "        super(WithLossCellG, self).__init__(auto_prefix=True)\n",
    "        self.netD = netD\n",
    "        self.netG = netG\n",
    "        self.loss_fn = loss_fn\n",
    "\n",
    "    def construct(self, latent_code):\n",
    "        \"\"\"构建生成器损失计算结构\"\"\"\n",
    "        ones = ops.Ones()\n",
    "        fake_data = self.netG(latent_code)\n",
    "        out = self.netD(fake_data)\n",
    "        label = ones(out.shape, mstype.float32)\n",
    "        loss = self.loss_fn(out, label)\n",
    "        return loss\n",
    "\n",
    "class WithLossCellD(nn.Cell):\n",
    "    \"\"\"连接判别器和损失\"\"\"\n",
    "    def __init__(self, netD, netG, loss_fn):\n",
    "        super(WithLossCellD, self).__init__(auto_prefix=True)\n",
    "        self.netD = netD\n",
    "        self.netG = netG\n",
    "        self.loss_fn = loss_fn\n",
    "\n",
    "    def construct(self, real_data, latent_code):\n",
    "        \"\"\"构建判别器损失计算结构\"\"\"\n",
    "        ones = ops.Ones()\n",
    "        zeros = ops.Zeros()\n",
    "\n",
    "        out1 = self.netD(real_data)\n",
    "        label1 = ones(out1.shape, mstype.float32)\n",
    "        loss1 = self.loss_fn(out1, label1)\n",
    "\n",
    "        fake_data = self.netG(latent_code)\n",
    "        fake_data = ops.stop_gradient(fake_data)\n",
    "        out2 = self.netD(fake_data)\n",
    "        label2 = zeros(out2.shape, mstype.float32)\n",
    "        loss2 = self.loss_fn(out2, label2)\n",
    "        return loss1 + loss2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 损失函数和优化器\n",
    "\n",
    "当定义了`D`和`G`后，接下来将使用MindSpore中定义的二进制交叉熵损失函数[BCELoss](https://www.mindspore.cn/docs/api/zh-CN/r1.3/api_python/nn/mindspore.nn.BCELoss.html)\n",
    "，为`D`和`G`加上损失函数和优化器。\n",
    "\n",
    "这里设置了两个单独的优化器，一个用于`D`，另一个用于`G`。这两个都是`lr = 0.0002`和`beta1 = 0.5`的Adam优化器。为此将真实标签定义为1，将虚假标签定义为0，该标签在分别计算`D`和`G`的损失时使用。\n",
    "\n",
    "为了跟踪生成器的学习进度，将生成一批固定的遵循高斯分布的隐向量 `fixed_noise`。在训练的过程中，定期将`fixed_noise`输入到`G`中，可以看到隐向量生成的图像。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义损失函数\n",
    "criterion = nn.BCELoss(reduction='mean')\n",
    "\n",
    "# 创建一批隐向量用来观察G\n",
    "np.random.seed(1)\n",
    "fixed_noise = Tensor(np.random.randn(64, nz, 1, 1),dtype=mstype.float32)\n",
    "\n",
    "# 为生成器和判别器设置优化器\n",
    "optimizerD = nn.Adam(netD.trainable_params(), learning_rate=lr, beta1=beta1)\n",
    "optimizerG = nn.Adam(netG.trainable_params(), learning_rate=lr, beta1=beta1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 训练\n",
    "\n",
    "训练分为两个主要部分：训练判别器和训练生成器。\n",
    "\n",
    "- 训练判别器\n",
    "\n",
    "  训练判别器的目的是最大程度地提高判别图像真伪的概率。按照Goodfellow的方法，是希望通过提高其随机梯度来更新判别器，所以我们要最大化$log D(x) + log(1 - D(G(z))$的值。\n",
    "\n",
    "\n",
    "- 训练生成器\n",
    "\n",
    "  如DCGAN论文所述，我们希望通过最小化$log(1 - D(G(z)))$来训练生成器，以产生更好的虚假图像。\n",
    "\n",
    "在这两个部分中，分别获取训练过程中的损失，并在每个周期结束时进行统计，将`fixed_noise`批量推送到生成器中，以直观地跟踪`G`的训练进度。\n",
    "\n",
    "下面进行训练："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 定义DCGAN网络。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DCGAN(nn.Cell):\n",
    "    def __init__(self, myTrainOneStepCellForD, myTrainOneStepCellForG):\n",
    "        super(DCGAN, self).__init__(auto_prefix=True)\n",
    "        self.myTrainOneStepCellForD = myTrainOneStepCellForD\n",
    "        self.myTrainOneStepCellForG = myTrainOneStepCellForG\n",
    "\n",
    "    def construct(self, real_data, latent_code):\n",
    "        output_D = self.myTrainOneStepCellForD(real_data, latent_code).view(-1)\n",
    "        netD_loss = output_D.mean()\n",
    "        output_G = self.myTrainOneStepCellForG(latent_code).view(-1)\n",
    "        netG_loss = output_G.mean()\n",
    "        return netD_loss, netG_loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 实例化生成器和判别器的`WithLossCell`和`TrainOneStepCell`。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 实例化WithLossCell\n",
    "netD_with_criterion = WithLossCellD(netD, netG, criterion)\n",
    "netG_with_criterion = WithLossCellG(netD, netG, criterion)\n",
    "\n",
    "# 实例化TrainOneStepCell\n",
    "myTrainOneStepCellForD = nn.TrainOneStepCell(netD_with_criterion, optimizerD)\n",
    "myTrainOneStepCellForG = nn.TrainOneStepCell(netG_with_criterion, optimizerG)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 循环训练网络，每经过50次迭代，就收集生成器和判别器的损失，以便于后面绘制训练过程中损失函数的图像。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1/10][0/54]\tLoss_D: 2.4556\tLoss_G: 3.0041\n",
      "[1/10][50/54]\tLoss_D: 0.1433\tLoss_G: 7.6950\n",
      "[2/10][0/54]\tLoss_D: 0.1365\tLoss_G: 8.8596\n",
      "[2/10][50/54]\tLoss_D: 0.1310\tLoss_G: 8.7747\n",
      "[3/10][0/54]\tLoss_D: 0.0504\tLoss_G: 10.5596\n",
      "[3/10][50/54]\tLoss_D: 0.8163\tLoss_G: 8.0759\n",
      "[4/10][0/54]\tLoss_D: 0.3023\tLoss_G: 5.7986\n",
      "[4/10][50/54]\tLoss_D: 0.5194\tLoss_G: 4.3674\n",
      "[5/10][0/54]\tLoss_D: 0.3352\tLoss_G: 3.4594\n",
      "[5/10][50/54]\tLoss_D: 0.4974\tLoss_G: 4.4283\n",
      "[6/10][0/54]\tLoss_D: 0.3801\tLoss_G: 4.0097\n",
      "[6/10][50/54]\tLoss_D: 0.8006\tLoss_G: 6.6378\n",
      "[7/10][0/54]\tLoss_D: 0.3117\tLoss_G: 4.2992\n",
      "[7/10][50/54]\tLoss_D: 0.2790\tLoss_G: 4.5312\n",
      "[8/10][0/54]\tLoss_D: 0.2849\tLoss_G: 3.6189\n",
      "[8/10][50/54]\tLoss_D: 0.2666\tLoss_G: 3.8770\n",
      "[9/10][0/54]\tLoss_D: 0.4683\tLoss_G: 5.4351\n",
      "[9/10][50/54]\tLoss_D: 0.5192\tLoss_G: 1.4136\n",
      "[10/10][0/54]\tLoss_D: 1.4602\tLoss_G: 9.7650\n",
      "[10/10][50/54]\tLoss_D: 0.5070\tLoss_G: 5.3808\n"
     ]
    }
   ],
   "source": [
    "# 实例化DCGAN网络\n",
    "dcgan = DCGAN(myTrainOneStepCellForD, myTrainOneStepCellForG)\n",
    "dcgan.set_train()\n",
    "\n",
    "#创建迭代器\n",
    "data_loader = data.create_dict_iterator(output_numpy=True, num_epochs=num_epochs)\n",
    "G_losses = []\n",
    "D_losses = []\n",
    "iters = 0\n",
    "image_list = []\n",
    "\n",
    "# 开始循环训练\n",
    "print(\"Starting Training Loop...\")\n",
    "\n",
    "for epoch in range(num_epochs):\n",
    "    # 为每轮训练读入数据\n",
    "    for i, d in enumerate(data_loader):\n",
    "        real_data = Tensor(d['image'])\n",
    "        latent_code = Tensor(d[\"latent_code\"])\n",
    "        netD_loss, netG_loss = dcgan(real_data, latent_code)\n",
    "        if i % 50 == 0:\n",
    "            # 输出训练记录\n",
    "            print('[%d/%d][%d/%d]\\tLoss_D: %.4f\\tLoss_G: %.4f'% (epoch + 1, num_epochs, i, size, netD_loss.asnumpy(), netG_loss.asnumpy()))\n",
    "        D_losses.append(netD_loss.asnumpy())\n",
    "        G_losses.append(netG_loss.asnumpy())\n",
    "        if (iters % 100) == 0 or ((epoch == num_epochs) and (i == size-1)):\n",
    "            img = netG(fixed_noise)\n",
    "            image_list.append(img)    \n",
    "        iters += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## 结果\n",
    "\n",
    "- 运行下面代码，描绘`D`和`G`损失与训练迭代的关系图："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10,5))\n",
    "plt.title(\"Generator and Discriminator Loss During Training\")\n",
    "plt.plot(G_losses,label=\"G\",color='blue')\n",
    "plt.plot(D_losses,label=\"D\",color='orange')\n",
    "plt.xlabel(\"iterations\")\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 可视化训练过程中通过隐向量`fixed_noise`生成的图像，每次只取9张图像展示。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![gif](images/SDGIF_Rusult_1.gif)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> 由上图可见训练过的网络成功生成了虚假名人图像。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}