{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# GAN图像生成\n",
    "\n",
    "[![下载Notebook](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/resource/_static/logo_notebook.svg)](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/master/tutorials/application/zh_cn/generative/mindspore_gan.ipynb) [![下载样例代码](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/resource/_static/logo_download_code.svg)](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/master/tutorials/application/zh_cn/generative/mindspore_gan.py) [![查看源文件](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/resource/_static/logo_source.svg)](https://gitee.com/mindspore/docs/blob/master/tutorials/application/source_zh_cn/generative/gan.ipynb)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 模型简介\n",
    "\n",
    "生成式对抗网络(Generative Adversarial Networks，GAN)是一种生成式机器学习模型，是近年来复杂分布上无监督学习最具前景的方法之一。\n",
    "\n",
    "最初，GAN由Ian J. Goodfellow于2014年发明，并在论文[Generative Adversarial Nets](https://papers.nips.cc/paper/5423-generative-adversarial-nets.pdf)中首次进行了描述，其主要由两个不同的模型共同组成——生成器(Generative Model)和判别器(Discriminative Model)：\n",
    "\n",
    "- 生成器的任务是生成看起来像训练图像的“假”图像；\n",
    "- 判别器需要判断从生成器输出的图像是真实的训练图像还是虚假的图像。\n",
    "\n",
    "GAN通过设计生成模型和判别模型这两个模块，使其互相博弈学习产生了相当好的输出。\n",
    "\n",
    "GAN模型的核心在于提出了通过对抗过程来估计生成模型这一全新框架。在这个框架中，将会同时训练两个模型——捕捉数据分布的生成模型 $G$ 和估计样本是否来自训练数据的判别模型 $D$ 。\n",
    "\n",
    "在训练过程中，生成器会不断尝试通过生成更好的假图像来骗过判别器，而判别器在这过程中也会逐步提升判别能力。这种博弈的平衡点是，当生成器生成的假图像和训练数据图像的分布完全一致时，判别器拥有50%的真假判断置信度。\n",
    "\n",
    "用 $x$ 代表图像数据，用 $D(x)$表示判别器网络给出图像判定为真实图像的概率。在判别过程中，$D(x)$ 需要处理作为二进制文件的大小为 $1\\times 28\\times 28$ 的图像数据。当 $x$ 来自训练数据时，$D(x)$ 数值应该趋近于 $1$ ；而当 $x$ 来自生成器时，$D(x)$ 数值应该趋近于 $0$ 。因此 $D(x)$ 也可以被认为是传统的二分类器。\n",
    "\n",
    "用 $z$ 代表标准正态分布中提取出的隐码(隐向量)，用 $G(z)$：表示将隐码(隐向量) $z$ 映射到数据空间的生成器函数。函数 $G(z)$ 的目标是将服从高斯分布的随机噪声 $z$ 通过生成网络变换为近似于真实分布 $p_{data}(x)$ 的数据分布，我们希望找到 $θ$ 使得 $p_{G}(x;\\theta)$ 和 $p_{data}(x)$ 尽可能的接近，其中 $\\theta$ 代表网络参数。\n",
    "\n",
    "$D(G(z))$ 表示生成器 $G$ 生成的假图像被判定为真实图像的概率，如[Generative Adversarial Nets](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",
    "$$\n",
    "\\min\\limits_{G}\\max\\limits_{D} V(D,G)=E_{x\\sim p_{data}\\;\\,(x)}[\\log D(x)]+E_{z\\sim p_{z}\\,(z)}[\\log (1-D(G(z)))]\n",
    "$$\n",
    "\n",
    "从理论上讲，此博弈游戏的平衡点是$p_{G}(x;\\theta) = p_{data}(x)$，此时判别器会随机猜测输入是真图像还是假图像。下面我们简要说明生成器和判别器的博弈过程：\n",
    "\n",
    "1. 在训练刚开始的时候，生成器和判别器的质量都比较差，生成器会随机生成一个数据分布。\n",
    "2. 判别器通过求取梯度和损失函数对网络进行优化，将靠近真实数据分布的数据判定为1，将靠近生成器生成出来数据分布的数据判定为0。\n",
    "3. 生成器通过优化，生成出更加贴近真实数据分布的数据。\n",
    "4. 生成器所生成的数据和真实数据达到相同的分布，此时判别器的输出为1/2。\n",
    "\n",
    "![gan](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/tutorials/application/source_zh_cn/cv/images/gan_image.png)\n",
    "\n",
    "在上图中，蓝色虚线表示判别器，黑色虚线表示真实数据分布，绿色实线表示生成器生成的虚假数据分布，$z$ 表示隐码，$x$ 表示生成的虚假图像 $G(z)$。该图片来源于[Generative Adversarial Nets](https://papers.nips.cc/paper/5423-generative-adversarial-nets.pdf)。详细的训练方法介绍见原论文。\n",
    "\n",
    "## 数据集\n",
    "\n",
    "### 数据集简介\n",
    "\n",
    "[MNIST手写数字数据集](http://yann.lecun.com/exdb/mnist/)是NIST数据集的子集，共有70000张手写数字图片，包含60000张训练样本和10000张测试样本，数字图片为二进制文件，图片大小为28\\*28，单通道。图片已经预先进行了尺寸归一化和中心化处理。\n",
    "\n",
    "本案例将使用MNIST手写数字数据集来训练一个生成式对抗网络，使用该网络模拟生成手写数字图片。\n",
    "\n",
    "### 数据集下载\n",
    "\n",
    "使用`download`接口下载数据集，并将下载后的数据集自动解压到当前目录下。数据下载之前需要使用`pip install download`安装`download`包。\n",
    "\n",
    "下载解压后的数据集目录结构如下：\n",
    "\n",
    "```text\n",
    "./MNIST_Data/\n",
    "├─ train\n",
    "│ ├─ train-images-idx3-ubyte\n",
    "│ └─ train-labels-idx1-ubyte\n",
    "└─ test\n",
    "   ├─ t10k-images-idx3-ubyte\n",
    "   └─ t10k-labels-idx1-ubyte\n",
    "```\n",
    "\n",
    "数据下载的代码如下：\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-02-09T09:45:06.383718Z",
     "start_time": "2023-02-09T09:44:40.500860Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading data from https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/MNIST_Data.zip (10.3 MB)\n",
      "\n",
      "file_sizes: 100%|███████████████████████████| 10.8M/10.8M [00:23<00:00, 455kB/s]\n",
      "Extracting zip file...\n",
      "Successfully downloaded / unzipped to .\n"
     ]
    }
   ],
   "source": [
    "# 数据下载\n",
    "from download import download\n",
    "\n",
    "url = \"https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/MNIST_Data.zip\"\n",
    "download(url, \".\", kind=\"zip\", replace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 数据加载\n",
    "\n",
    "使用MindSpore自己的`MnistDatase`接口，读取和解析MNIST数据集的源文件构建数据集。然后对数据进行一些前处理。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-02-09T09:45:20.017779Z",
     "start_time": "2023-02-09T09:45:06.385713Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iter size: 468\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import mindspore.dataset as ds\n",
    "\n",
    "batch_size = 128\n",
    "latent_size = 100  # 隐码的长度\n",
    "\n",
    "train_dataset = ds.MnistDataset(dataset_dir='./MNIST_Data/train')\n",
    "test_dataset = ds.MnistDataset(dataset_dir='./MNIST_Data/test')\n",
    "\n",
    "def data_load(dataset):\n",
    "    dataset1 = ds.GeneratorDataset(dataset, [\"image\", \"label\"], shuffle=True, python_multiprocessing=False)\n",
    "    # 数据增强\n",
    "    mnist_ds = dataset1.map(\n",
    "        operations=lambda x: (x.astype(\"float32\"), np.random.normal(size=latent_size).astype(\"float32\")),\n",
    "        output_columns=[\"image\", \"latent_code\"])\n",
    "    mnist_ds = mnist_ds.project([\"image\", \"latent_code\"])\n",
    "\n",
    "    # 批量操作\n",
    "    mnist_ds = mnist_ds.batch(batch_size, True)\n",
    "\n",
    "    return mnist_ds\n",
    "\n",
    "mnist_ds = data_load(train_dataset)\n",
    "\n",
    "iter_size = mnist_ds.get_dataset_size()\n",
    "print('Iter size: %d' % iter_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 数据集可视化\n",
    "\n",
    "通过`create_dict_iterator`函数将数据转换成字典迭代器，然后使用`matplotlib`模块可视化部分训练数据。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-02-09T09:45:21.094899Z",
     "start_time": "2023-02-09T09:45:20.018778Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 300x300 with 25 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "data_iter = next(mnist_ds.create_dict_iterator(output_numpy=True))\n",
    "figure = plt.figure(figsize=(3, 3))\n",
    "cols, rows = 5, 5\n",
    "for idx in range(1, cols * rows + 1):\n",
    "    image = data_iter['image'][idx]\n",
    "    figure.add_subplot(rows, cols, idx)\n",
    "    plt.axis(\"off\")\n",
    "    plt.imshow(image.squeeze(), cmap=\"gray\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 隐码构造\n",
    "\n",
    "为了跟踪生成器的学习进度，我们在训练的过程中的每轮迭代结束后，将一组固定的遵循高斯分布的隐码`test_noise`输入到生成器中，通过固定隐码所生成的图像效果来评估生成器的好坏。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-02-09T09:45:21.152791Z",
     "start_time": "2023-02-09T09:45:21.096895Z"
    }
   },
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "from mindspore import Tensor\n",
    "from mindspore.common import dtype\n",
    "\n",
    "# 利用随机种子创建一批隐码\n",
    "np.random.seed(2323)\n",
    "test_noise = Tensor(np.random.normal(size=(25, 100)), dtype.float32)\n",
    "random.shuffle(test_noise)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 模型构建\n",
    "\n",
    "本案例实现中所搭建的 GAN 模型结构与原论文中提出的 GAN 结构大致相同，但由于所用数据集 MNIST 为单通道小尺寸图片，可识别参数少，便于训练，我们在判别器和生成器中采用全连接网络架构和 `ReLU` 激活函数即可达到令人满意的效果，且省略了原论文中用于减少参数的 `Dropout` 策略和可学习激活函数 `Maxout`。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 生成器\n",
    "\n",
    "生成器 `Generator` 的功能是将隐码映射到数据空间。由于数据是图像，这一过程也会创建与真实图像大小相同的灰度图像(或 RGB 彩色图像)。在本案例演示中，该功能通过五层 `Dense` 全连接层来完成的，每层都与 `BatchNorm1d` 批归一化层和 `ReLU` 激活层配对，输出数据会经过 `Tanh` 函数，使其返回 [-1,1] 的数据范围内。注意实例化生成器之后需要修改参数的名称，不然静态图模式下会报错。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-02-09T09:45:21.190676Z",
     "start_time": "2023-02-09T09:45:21.153742Z"
    }
   },
   "outputs": [],
   "source": [
    "from mindspore import nn\n",
    "import mindspore.ops as ops\n",
    "\n",
    "img_size = 28  # 训练图像长（宽）\n",
    "\n",
    "class Generator(nn.Cell):\n",
    "    def __init__(self, latent_size, auto_prefix=True):\n",
    "        super(Generator, self).__init__(auto_prefix=auto_prefix)\n",
    "        self.model = nn.SequentialCell()\n",
    "        # [N, 100] -> [N, 128]\n",
    "        # 输入一个100维的0～1之间的高斯分布，然后通过第一层线性变换将其映射到256维\n",
    "        self.model.append(nn.Dense(latent_size, 128))\n",
    "        self.model.append(nn.ReLU())\n",
    "        # [N, 128] -> [N, 256]\n",
    "        self.model.append(nn.Dense(128, 256))\n",
    "        self.model.append(nn.BatchNorm1d(256))\n",
    "        self.model.append(nn.ReLU())\n",
    "        # [N, 256] -> [N, 512]\n",
    "        self.model.append(nn.Dense(256, 512))\n",
    "        self.model.append(nn.BatchNorm1d(512))\n",
    "        self.model.append(nn.ReLU())\n",
    "        # [N, 512] -> [N, 1024]\n",
    "        self.model.append(nn.Dense(512, 1024))\n",
    "        self.model.append(nn.BatchNorm1d(1024))\n",
    "        self.model.append(nn.ReLU())\n",
    "        # [N, 1024] -> [N, 784]\n",
    "        # 经过线性变换将其变成784维\n",
    "        self.model.append(nn.Dense(1024, img_size * img_size))\n",
    "        # 经过Tanh激活函数是希望生成的假的图片数据分布能够在-1～1之间\n",
    "        self.model.append(nn.Tanh())\n",
    "\n",
    "    def construct(self, x):\n",
    "        img = self.model(x)\n",
    "        return ops.reshape(img, (-1, 1, 28, 28))\n",
    "\n",
    "net_g = Generator(latent_size)\n",
    "net_g.update_parameters_name('generator')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 判别器\n",
    "\n",
    "如前所述，判别器 `Discriminator` 是一个二分类网络模型，输出判定该图像为真实图的概率。主要通过一系列的 `Dense` 层和 `LeakyReLU` 层对其进行处理，最后通过 `Sigmoid` 激活函数，使其返回 [0, 1] 的数据范围内，得到最终概率。注意实例化判别器之后需要修改参数的名称，不然静态图模式下会报错。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-02-09T09:45:21.207645Z",
     "start_time": "2023-02-09T09:45:21.191642Z"
    }
   },
   "outputs": [],
   "source": [
    " # 判别器\n",
    "class Discriminator(nn.Cell):\n",
    "    def __init__(self, auto_prefix=True):\n",
    "        super().__init__(auto_prefix=auto_prefix)\n",
    "        self.model = nn.SequentialCell()\n",
    "        # [N, 784] -> [N, 512]\n",
    "        self.model.append(nn.Dense(img_size * img_size, 512))  # 输入特征数为784，输出为512\n",
    "        self.model.append(nn.LeakyReLU())  # 默认斜率为0.2的非线性映射激活函数\n",
    "        # [N, 512] -> [N, 256]\n",
    "        self.model.append(nn.Dense(512, 256))  # 进行一个线性映射\n",
    "        self.model.append(nn.LeakyReLU())\n",
    "        # [N, 256] -> [N, 1]\n",
    "        self.model.append(nn.Dense(256, 1))\n",
    "        self.model.append(nn.Sigmoid())  # 二分类激活函数，将实数映射到[0,1]\n",
    "\n",
    "    def construct(self, x):\n",
    "        x_flat = ops.reshape(x, (-1, img_size * img_size))\n",
    "        return self.model(x_flat)\n",
    "\n",
    "net_d = Discriminator()\n",
    "net_d.update_parameters_name('discriminator')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 损失函数和优化器\n",
    "\n",
    "定义了 `Generator` 和 `Discriminator` 后，损失函数使用MindSpore中二进制交叉熵损失函数`BCELoss` ；这里生成器和判别器都是使用`Adam`优化器，但是需要构建两个不同名称的优化器，分别用于更新两个模型的参数，详情见下文代码。注意优化器的参数名称也需要修改。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-02-09T09:45:21.267439Z",
     "start_time": "2023-02-09T09:45:21.208597Z"
    }
   },
   "outputs": [],
   "source": [
    "lr = 0.0002  # 学习率\n",
    "\n",
    "# 损失函数\n",
    "adversarial_loss = nn.BCELoss(reduction='mean')\n",
    "\n",
    "# 优化器\n",
    "optimizer_d = nn.Adam(net_d.trainable_params(), learning_rate=lr, beta1=0.5, beta2=0.999)\n",
    "optimizer_g = nn.Adam(net_g.trainable_params(), learning_rate=lr, beta1=0.5, beta2=0.999)\n",
    "optimizer_g.update_parameters_name('optim_g')\n",
    "optimizer_d.update_parameters_name('optim_d')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 模型训练\n",
    "\n",
    "训练分为两个主要部分。\n",
    "\n",
    "第一部分是训练判别器。训练判别器的目的是最大程度地提高判别图像真伪的概率。按照原论文的方法，通过提高其随机梯度来更新判别器，最大化 $log D(x) + log(1 - D(G(z))$ 的值。\n",
    "\n",
    "第二部分是训练生成器。如论文所述，最小化 $log(1 - D(G(z)))$ 来训练生成器，以产生更好的虚假图像。\n",
    "\n",
    "在这两个部分中，分别获取训练过程中的损失，并在每轮迭代结束时进行测试，将隐码批量推送到生成器中，以直观地跟踪生成器 `Generator` 的训练效果。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-02-09T09:45:21.273427Z",
     "start_time": "2023-02-09T09:45:21.268436Z"
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import time\n",
    "import matplotlib.pyplot as plt\n",
    "import mindspore as ms\n",
    "from mindspore import Tensor, save_checkpoint\n",
    "\n",
    "total_epoch = 200  # 训练周期数\n",
    "batch_size = 128  # 用于训练的训练集批量大小\n",
    "\n",
    "# 加载预训练模型的参数\n",
    "pred_trained = False\n",
    "pred_trained_g = './result/checkpoints/Generator99.ckpt'\n",
    "pred_trained_d = './result/checkpoints/Discriminator99.ckpt'\n",
    "\n",
    "checkpoints_path = \"./result/checkpoints\"  # 结果保存路径\n",
    "image_path = \"./result/images\"  # 测试结果保存路径"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-02-09T13:36:50.742960Z",
     "start_time": "2023-02-09T09:45:21.274421Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:[  0/200], step:[   0/ 468], loss_d:1.383930 , loss_g:0.693423 , time:0.864688s, lr:0.000200\n",
      "Epoch:[  0/200], step:[  10/ 468], loss_d:1.356453 , loss_g:0.548430 , time:0.122673s, lr:0.000200\n",
      "Epoch:[  0/200], step:[  20/ 468], loss_d:1.386923 , loss_g:0.628228 , time:0.120677s, lr:0.000200\n",
      "Epoch:[  0/200], step:[  30/ 468], loss_d:1.385639 , loss_g:0.649491 , time:0.124667s, lr:0.000200\n",
      "Epoch:[  0/200], step:[  40/ 468], loss_d:1.365866 , loss_g:0.683650 , time:0.122672s, lr:0.000200\n",
      "...\n",
      "Epoch:[ 99/200], step:[ 440/ 468], loss_d:1.170306 , loss_g:0.954169 , time:0.113697s, lr:0.000200\n",
      "Epoch:[ 99/200], step:[ 450/ 468], loss_d:1.187954 , loss_g:0.970897 , time:0.113697s, lr:0.000200\n",
      "Epoch:[ 99/200], step:[ 460/ 468], loss_d:1.277891 , loss_g:0.930688 , time:0.116688s, lr:0.000200\n",
      "time of epoch 100 is 61.76s\n",
      "Epoch:[100/200], step:[   0/ 468], loss_d:1.197745 , loss_g:0.951075 , time:0.134640s, lr:0.000200\n",
      "Epoch:[100/200], step:[  10/ 468], loss_d:1.241353 , loss_g:0.939583 , time:0.131648s, lr:0.000200\n",
      "Epoch:[100/200], step:[  20/ 468], loss_d:1.222481 , loss_g:0.900680 , time:0.129653s, lr:0.000200\n",
      "...\n",
      "Epoch:[199/200], step:[ 420/ 468], loss_d:1.215858 , loss_g:1.071604 , time:0.151593s, lr:0.000200\n",
      "Epoch:[199/200], step:[ 430/ 468], loss_d:1.238803 , loss_g:0.920928 , time:0.135638s, lr:0.000200\n",
      "Epoch:[199/200], step:[ 440/ 468], loss_d:1.212080 , loss_g:0.954983 , time:0.134640s, lr:0.000200\n",
      "Epoch:[199/200], step:[ 450/ 468], loss_d:1.236587 , loss_g:0.897825 , time:0.133643s, lr:0.000200\n",
      "Epoch:[199/200], step:[ 460/ 468], loss_d:1.214701 , loss_g:0.939405 , time:0.135638s, lr:0.000200\n",
      "time of epoch 200 is 71.98s\n"
     ]
    }
   ],
   "source": [
    "# 生成器计算损失过程\n",
    "def generator_forward(test_noises):\n",
    "    fake_data = net_g(test_noises)\n",
    "    fake_out = net_d(fake_data)\n",
    "    loss_g = adversarial_loss(fake_out, ops.ones_like(fake_out))\n",
    "    return loss_g\n",
    "\n",
    "# 判别器计算损失过程\n",
    "def discriminator_forward(real_data, test_noises):\n",
    "    fake_data = net_g(test_noises)\n",
    "    fake_out = net_d(fake_data)\n",
    "    real_out = net_d(real_data)\n",
    "    real_loss = adversarial_loss(real_out, ops.ones_like(real_out))\n",
    "    fake_loss = adversarial_loss(fake_out, ops.zeros_like(fake_out))\n",
    "    loss_d = real_loss + fake_loss\n",
    "    return loss_d\n",
    "\n",
    "# 梯度方法\n",
    "grad_g = ms.value_and_grad(generator_forward, None, net_g.trainable_params())\n",
    "grad_d = ms.value_and_grad(discriminator_forward, None, net_d.trainable_params())\n",
    "\n",
    "def train_step(real_data, latent_code):\n",
    "    # 计算判别器损失和梯度\n",
    "    loss_d, grads_d = grad_d(real_data, latent_code)\n",
    "    optimizer_d(grads_d)\n",
    "    loss_g, grads_g = grad_g(latent_code)\n",
    "    optimizer_g(grads_g)\n",
    "\n",
    "    return loss_d, loss_g\n",
    "\n",
    "# 保存生成的test图像\n",
    "def save_imgs(gen_imgs1, idx):\n",
    "    for i3 in range(gen_imgs1.shape[0]):\n",
    "        plt.subplot(5, 5, i3 + 1)\n",
    "        plt.imshow(gen_imgs1[i3, 0, :, :] / 2 + 0.5, cmap=\"gray\")\n",
    "        plt.axis(\"off\")\n",
    "    plt.savefig(image_path + \"/test_{}.png\".format(idx))\n",
    "\n",
    "# 设置参数保存路径\n",
    "os.makedirs(checkpoints_path, exist_ok=True)\n",
    "# 设置中间过程生成图片保存路径\n",
    "os.makedirs(image_path, exist_ok=True)\n",
    "\n",
    "net_g.set_train()\n",
    "net_d.set_train()\n",
    "\n",
    "# 储存生成器和判别器loss\n",
    "losses_g, losses_d = [], []\n",
    "\n",
    "for epoch in range(total_epoch):\n",
    "    start = time.time()\n",
    "    for (iter, data) in enumerate(mnist_ds):\n",
    "        start1 = time.time()\n",
    "        image, latent_code = data\n",
    "        image = (image - 127.5) / 127.5  # [0, 255] -> [-1, 1]\n",
    "        image = image.reshape(image.shape[0], 1, image.shape[1], image.shape[2])\n",
    "        d_loss, g_loss = train_step(image, latent_code)\n",
    "        end1 = time.time()\n",
    "        if iter % 10 == 0:\n",
    "            print(f\"Epoch:[{int(epoch):>3d}/{int(total_epoch):>3d}], \"\n",
    "                  f\"step:[{int(iter):>4d}/{int(iter_size):>4d}], \"\n",
    "                  f\"loss_d:{d_loss.asnumpy():>4f} , \"\n",
    "                  f\"loss_g:{g_loss.asnumpy():>4f} , \"\n",
    "                  f\"time:{(end1 - start1):>3f}s, \"\n",
    "                  f\"lr:{lr:>6f}\")\n",
    "\n",
    "    end = time.time()\n",
    "    print(\"time of epoch {} is {:.2f}s\".format(epoch + 1, end - start))\n",
    "\n",
    "    losses_d.append(d_loss.asnumpy())\n",
    "    losses_g.append(g_loss.asnumpy())\n",
    "\n",
    "    # 每个epoch结束后，使用生成器生成一组图片\n",
    "    gen_imgs = net_g(test_noise)\n",
    "    save_imgs(gen_imgs.asnumpy(), epoch)\n",
    "\n",
    "    # 根据epoch保存模型权重文件\n",
    "    if epoch % 1 == 0:\n",
    "        save_checkpoint(net_g, checkpoints_path + \"/Generator%d.ckpt\" % (epoch))\n",
    "        save_checkpoint(net_d, checkpoints_path + \"/Discriminator%d.ckpt\" % (epoch))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 效果展示\n",
    "\n",
    "运行下面代码，描绘`D`和`G`损失与训练迭代的关系图："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-02-10T01:39:37.298891Z",
     "start_time": "2023-02-10T01:39:37.177217Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(6, 4))\n",
    "plt.title(\"Generator and Discriminator Loss During Training\")\n",
    "plt.plot(losses_g, label=\"G\", color='blue')\n",
    "plt.plot(losses_d, label=\"D\", color='orange')\n",
    "plt.xlim(-20, 220)\n",
    "plt.ylim(0, 3.5)\n",
    "plt.xlabel(\"iterations\")\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-02-07T08:15:38.144519Z",
     "start_time": "2023-02-07T08:15:38.137537Z"
    }
   },
   "source": [
    "可视化训练过程中通过隐向量生成的图像。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-02-09T13:36:54.052385Z",
     "start_time": "2023-02-09T13:36:50.876603Z"
    }
   },
   "outputs": [],
   "source": [
    "import cv2\n",
    "import matplotlib.animation as animation\n",
    "\n",
    "# 将训练过程中生成的测试图转为动态图\n",
    "image_list = []\n",
    "for i in range(total_epoch):\n",
    "    image_list.append(cv2.imread(image_path + \"/test_{}.png\".format(i), cv2.IMREAD_GRAYSCALE))\n",
    "show_list = []\n",
    "fig = plt.figure(dpi=70)\n",
    "for epoch in range(0, len(image_list), 5):\n",
    "    plt.axis(\"off\")\n",
    "    show_list.append([plt.imshow(image_list[epoch], cmap='gray')])\n",
    "\n",
    "ani = animation.ArtistAnimation(fig, show_list, interval=1000, repeat_delay=1000, blit=True)\n",
    "ani.save('train_test.gif', writer='pillow', fps=1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![训练过程测试动态图](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/tutorials/application/source_zh_cn/generative/images/train_test.gif)\n",
    "\n",
    "从上面的图像可以看出，随着训练次数的增多，图像质量也越来越好。如果增大训练周期数，当 `epoch` 达到100以上时，生成的手写数字图片与数据集中的较为相似。下面我们通过加载生成器网络模型参数文件来生成图像，代码如下："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 模型推理\n",
    "\n",
    "下面我们通过加载生成器网络模型参数文件来生成图像，代码如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-02-09T13:36:54.707633Z",
     "start_time": "2023-02-09T13:36:54.053382Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 25 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import mindspore as ms\n",
    "\n",
    "test_ckpt = './result/checkpoints/Generator199.ckpt'\n",
    "\n",
    "parameter = ms.load_checkpoint(test_ckpt)\n",
    "ms.load_param_into_net(net_g, parameter)\n",
    "# 模型生成结果\n",
    "test_data = Tensor(np.random.normal(0, 1, (25, 100)).astype(np.float32))\n",
    "images = net_g(test_data).transpose(0, 2, 3, 1).asnumpy()\n",
    "# 结果展示\n",
    "fig = plt.figure(figsize=(3, 3), dpi=120)\n",
    "for i in range(25):\n",
    "    fig.add_subplot(5, 5, i + 1)\n",
    "    plt.axis(\"off\")\n",
    "    plt.imshow(images[i].squeeze(), cmap=\"gray\")\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "MindSpore",
   "language": "python",
   "name": "mindspore"
  },
  "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.9.15"
  },
  "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": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}