{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quantum Generative Adversarial Network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<em> Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. </em>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classical Generative Adversarial Network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Introduction to Generative Adversarial Network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generative Adversarial Network (GAN) is a generative model, which is a breakthrough in deep learning in recent years [1]. It contains two parts: the generator $G$ and the discriminator $D$. The generator accepts a random noise signal and uses it as input to generate the data we expect. The discriminator evaluates the received data $x$ and outputs a probability $P(x)$ that the data $x$ is real."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nash Equilibrium"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we use the idea of Nash equilibrium to discuss the convergence problem of GAN.\n",
    "\n",
    "Nash equilibrium refers to a non-cooperative game involving two or more participants, assuming that each participant knows other participants' equilibrium strategies. No participant can change one's strategy to benefit. In the game theory, if each participant chooses his strategy, and no player can benefit by changing the strategy while other participants remain the same, then the current set of strategy choices and their corresponding results constitute Nash Equilibrium.\n",
    "\n",
    "We can regard the training process of GAN as a game process between generator and discriminator. No matter what the generator's strategy is, the best strategy of the discriminator is to try to distinguish the real data and the generated data. And regardless of the strategy of the discriminator, the best strategy for the generator is to make the discriminator unable to distinguish. This game is a zero-sum game, which is one of non-cooperative game. That is, one party gains while the other party must lose. Therefore, there exists the Nash equilibrium strategy in the game between the generator and the discriminator. When there are enough samples of real data and the learning ability of both parties is strong enough, a Nash equilibrium point will eventually be reached. **The generator has the ability to generate real data, and the discriminator can no longer distinguish between generated data and real data.** \n",
    "\n",
    "GAN adopts the idea of Nash equilibrium. In GAN, the generator and the discriminator are playing a non-cooperative game. No matter what strategies the generator adopts, the best strategy of the discriminator is to discriminate as much as possible; and no matter what strategies the discriminator adopts, the best strategy of the generator is to make the discriminator unable to discriminate as much as possible. Therefore, the two parties' strategic combination in the game and the corresponding results constitute the Nash equilibrium. **When the Nash equilibrium is reached, the generator can to generate real data, and the discriminator cannot distinguish between the generated data and the real data**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Optimization goal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In GAN, we want to get an excellent generator (but only an excellent discriminator can accurately determine whether the generator is excellent). Our training's ideal result is that the discriminator cannot identify whether the data comes from real data or generated data.\n",
    "\n",
    "Therefore, our objective function is as follows:\n",
    "\n",
    "$$\n",
    "\\min_{G}\\max_{D} V(G,D)= \\min_{G}\\max_{D}\\mathbb{E}_{x\\sim P_{data}}[\\log D(x)] +\\mathbb{E}_{z\\sim P_{z}}[\\log(1-D(G(z)))]. \\tag{1}\n",
    "$$\n",
    "\n",
    "Here, $G$ represents the parameters of the generator and $D$ represents the parameters of the discriminator. In the actual process, the alternate training method is usually adopted; that is, first fix $G$, train $D$, then fix $D$, train $G$, and repeat. When the two's performance is sufficient, the model will converge, and the two will reach the Nash equilibrium."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Advantages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Compared with other generative models, GAN generates better results.\n",
    "- Theoretically, as long as it is a differentiable function, it can be used to build generators and discriminators, so it can be combined with deep neural networks to make deep generative models.\n",
    "- Compared with other generative models, GAN does not rely on prior assumptions, and we do not need to assume the probability distribution and law of the data in advance.\n",
    "- The form of data generated by GAN is also very simple, just forward propagation through the generator."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Disadvantages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- GAN does not require pre-modeling. Too much freedom makes training difficult to converge and unstable.\n",
    "- GAN has a vanishing gradient problem. In this case, there is no loss in the training of the discriminator, so there is no adequate gradient information to pass back to the generator to optimize itself.\n",
    "- There may be a problem of model collapse in the learning process of GAN. The generator degenerates, always generating the same sample points, and cannot continue learning. The discriminator also points to similar sample points in similar directions, and the model parameters are no longer updated, but the actual effect is feeble."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quantum Generative Adversarial Network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The quantum generative adversarial network is similar to the classical one, except that it is no longer used to generate classical data but generate quantum states [2-3]. In practice, if we have a quantum state, it will collapse to a certain eigenstate after observation and cannot be restored to the previous quantum state. Therefore, if we have a method that generates many identical (or similar) quantum states based on the existing target quantum state, it will be very convenient for our experiments.\n",
    "\n",
    "Assuming that our existing target quantum states all come from a mixed state, they belong to the same ensemble, and their density operator is $\\rho$. Then we need to have a generator $G$ whose input is noise data, denoted by the ensemble $\\rho_{z}=\\sum_{i}p_{i}|z_{i}\\rangle\\langle z_ {i}|$. Therefore, we take out a random noise sample $|z_{i}\\rangle$ every time and get the generated quantum state $|x\\rangle=G|z_{i}\\rangle$ after passing through the generator. We expect the generated $| x\\rangle$ that is close to the target quantum state $\\rho$.\n",
    "\n",
    "It is worth noting that for the ensemble of the target state and the ensemble of the noise data mentioned above, we think that there exists a physical device that can generate a quantum state from the ensemble. According to quantum physics, We can get a genuinely random quantum state every time. However, in computer programs, we need to simulate this process.\n",
    "\n",
    "We expect the discriminator to judge whether the quantum state we input is an existing target state or a generated quantum state. This process needs to be given by measurement.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A simple example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem Description"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For simplicity, we assume that the existing target quantum state is a pure state, and the input state for the generator is $|0\\rangle$.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The circuit to prepare the existing target quantum state:\n",
    "![QGAN-fig-target_state](figures/QGAN-fig-target_state.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The circuit of the generator is:\n",
    "![QGAN-fig-generator](figures/QGAN-fig-generator.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The circuit of the discriminator is:\n",
    "![QGAN-fig-discriminator](figures/QGAN-fig-discriminator.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By measuring the quantum state output by the discriminator, we can get the probability of judging the target state as the target state $P_{T}$ and the probability of judging the generated state as the target state $P_{G}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Specific process"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assuming that the existing target quantum state is $|\\psi\\rangle$, the quantum state generated by the generator is $|x\\rangle=G|00\\rangle$ (the generator uses a two-qubit circuit, of which the 0th qubit is a generated quantum state).\n",
    "\n",
    "The discriminator discriminates the data and obtains the quantum state $|\\phi\\rangle$ when the input is the target state, $|\\phi\\rangle=D(|\\psi\\rangle\\otimes |00\\rangle)$; When the input is generated state, $|\\phi\\rangle=D(G\\otimes I)|000\\rangle$.\n",
    "\n",
    "For the quantum state obtained by the discriminator, we also need to use the Pauli Z gate to measure the third qubit so as to obtain the judgment result of the input quantum state by the discriminator (that is, the probability that the discriminator thinks the input is the target state). First there is $M_{z}=I\\otimes I\\otimes\\sigma_{z}$, and the measurement result is $\\text{disc}_\\text{output}=\\langle\\phi|M_{z}|\\phi\\rangle$, so the probability of the measurement that the result is the target state is $P=(\\text{disc}_\\text{output}+1)/2$.\n",
    "\n",
    "We define the loss function of the discriminator as $\\mathcal{L}_{D}=P_{G}(\\text{gen}_\\theta, \\text{disc}_\\phi)-P_{T}(\\text{disc}_\\phi)$, The loss function of the generator is $\\mathcal{L}_{G}=-P_{G}(\\text{gen}_\\theta, \\text{disc}_\\phi)$. Here, $P_{G}$ and $P_{T}$ are the expressions of $P=(\\text{disc}_\\text{output}+1)/2$, when the input quantum state is the generated state and the target state, respectively. gen\\_theta and disc\\_phi are the parameters of the generator and discriminator circuits.\n",
    "\n",
    "So we only need to optimize the objective function $\\min_{\\text{disc}_\\phi}\\mathcal{L}_{D}$ and $\\min_{\\text{gen}_\\theta}\\mathcal{L}_{G}$ respectively. The discriminator and generator can be alternately trained."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Paddle Quantum Implementation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First import the relevant packages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-01-09T10:49:41.308412Z",
     "start_time": "2021-01-09T10:49:38.115680Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy\n",
    "import warnings\n",
    "import paddle\n",
    "import paddle_quantum\n",
    "from paddle_quantum.state import zero_state\n",
    "from paddle_quantum.ansatz import Circuit\n",
    "from paddle_quantum import Hamiltonian\n",
    "from paddle_quantum.gate import *\n",
    "from paddle_quantum.loss import ExpecVal\n",
    "from paddle_quantum.qinfo import partial_trace\n",
    "from tqdm import tqdm\n",
    "\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then define our network model QGAN."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-01-09T10:49:43.091496Z",
     "start_time": "2021-01-09T10:49:43.060879Z"
    }
   },
   "outputs": [],
   "source": [
    "# set the backend to density_matrix\n",
    "paddle_quantum.set_backend('density_matrix')\n",
    "\n",
    "class QGAN():\n",
    "    def __init__(self, target_state, LR, ITR, ITR_D, ITR_G):\n",
    "        \"\"\"\n",
    "        parameters\n",
    "        target_state: target state\n",
    "        LR:           learning rate\n",
    "        ITR:          number of iterations\n",
    "        ITR_D:        number of iterations for discriminator\n",
    "        ITR_G:        number of iterations for generator\n",
    "        \"\"\"\n",
    "        self.target_state = target_state.clone()\n",
    "\n",
    "        # Quantum circuit of generator\n",
    "        self.generator = Circuit(3)\n",
    "        self.generator.u3([0, 1])\n",
    "        self.generator.cnot([0, 1])\n",
    "        self.generator.u3(0)\n",
    "\n",
    "        # Quantum circuit of the discriminator\n",
    "        self.discriminator = Circuit(3)\n",
    "        self.discriminator.u3([0, 2])\n",
    "        self.discriminator.cnot([0, 2])\n",
    "        self.discriminator.u3(0)\n",
    "        \n",
    "        # Hyperparameters of training\n",
    "        self.LR = LR\n",
    "        self.ITR = ITR\n",
    "        self.ITR_D = ITR_D\n",
    "        self.ITR_G = ITR_G\n",
    "        \n",
    "        # Optimizer\n",
    "        self.optimizer = paddle.optimizer.SGD(\n",
    "            learning_rate=self.LR,\n",
    "            parameters=self.generator.parameters() + self.discriminator.parameters(),\n",
    "        )\n",
    "\n",
    "    def disc_target_as_target(self):\n",
    "        \"\"\"\n",
    "        The probability that the discriminator judges the target state as the target state\n",
    "        \"\"\"\n",
    "        state = self.discriminator(self.target_state)\n",
    "        expec_val_func = ExpecVal(Hamiltonian([[1.0, 'z2']]))\n",
    "        \n",
    "        # The judgment result of the discriminator on the target state\n",
    "        target_disc_output = expec_val_func(state)\n",
    "        prob_as_target = (target_disc_output + 1) / 2\n",
    "\n",
    "        return prob_as_target\n",
    "\n",
    "    def disc_gen_as_target(self):\n",
    "        \"\"\"\n",
    "        The probability that the discriminator judges the generated state as the target state\n",
    "        \"\"\"\n",
    "        # Get the quantum state generated by the generator\n",
    "        gen_state = self.generator()\n",
    "\n",
    "        state = self.discriminator(gen_state)\n",
    "        # The judgment result of the discriminator on the generated state\n",
    "        expec_val_func = ExpecVal(Hamiltonian([[1.0, 'z2']]))\n",
    "        gen_disc_output = expec_val_func(state)\n",
    "        prob_as_target = (gen_disc_output + 1) / 2\n",
    "\n",
    "        return prob_as_target\n",
    "    \n",
    "    def gen_loss_func(self):\n",
    "        \"\"\"\n",
    "        Calculate the loss function of the generator, the interval of the loss value is [-1, 0],\n",
    "        0 means extremely poor generation effect, -1 means excellent generation effect\n",
    "        \"\"\"\n",
    "        return -1 * self.disc_gen_as_target()\n",
    "\n",
    "    def disc_loss_func(self):\n",
    "        \"\"\"\n",
    "        Calculate the loss function of the discriminator, the loss value range is [-1, 1],\n",
    "        -1 means perfect distinction, 0 means indistinguishable, 1 means inverted distinction\n",
    "        \"\"\"\n",
    "        return self.disc_gen_as_target() - self.disc_target_as_target()\n",
    "\n",
    "    def get_target_state(self):\n",
    "        \"\"\"\n",
    "        Get the density matrix representation of the target state\n",
    "        \"\"\"\n",
    "        state = partial_trace(self.target_state, 2, 4, 2)\n",
    "\n",
    "        return state.numpy()\n",
    "\n",
    "    def get_generated_state(self):\n",
    "        \"\"\"\n",
    "        Get the density matrix representation of the generated state\n",
    "        \"\"\"\n",
    "        state = self.generator()\n",
    "        state = partial_trace(state, 2, 4, 2)\n",
    "\n",
    "        return state.numpy()\n",
    "    \n",
    "    def train(self):\n",
    "        \"\"\"\n",
    "        Train the QGAN\n",
    "        \"\"\"\n",
    "        \n",
    "        # Used to record the change of loss value\n",
    "        loss_history = []\n",
    "        pbar = tqdm(\n",
    "            desc=\"Training: \",\n",
    "            total=self.ITR * (self.ITR_G + self.ITR_D),\n",
    "            ncols=100,\n",
    "            ascii=True,\n",
    "        )\n",
    "\n",
    "        for _ in range(self.ITR):\n",
    "            # Train the discriminator\n",
    "            loss_disc_history = []\n",
    "            for _ in range(self.ITR_D):\n",
    "                pbar.update(1)\n",
    "                loss_disc = self.disc_loss_func()\n",
    "                loss_disc.backward()\n",
    "                self.optimizer.minimize(\n",
    "                    loss_disc,\n",
    "                    parameters=self.discriminator.parameters(),\n",
    "                    no_grad_set=self.generator.parameters(),\n",
    "                )\n",
    "                self.optimizer.clear_grad()\n",
    "                loss_disc_history.append(loss_disc.numpy()[0])\n",
    "\n",
    "            # Train the generator\n",
    "            loss_gen_history = []\n",
    "            for _ in range(self.ITR_G):\n",
    "                pbar.update(1)\n",
    "                loss_gen = self.gen_loss_func()\n",
    "                loss_gen.backward()\n",
    "                self.optimizer.minimize(\n",
    "                    loss_gen,\n",
    "                    parameters=self.generator.parameters(),\n",
    "                    no_grad_set=self.discriminator.parameters(),\n",
    "                )\n",
    "                self.optimizer.clear_grad()\n",
    "                loss_gen_history.append(loss_gen.numpy()[0])\n",
    "\n",
    "            loss_history.append((loss_disc_history, loss_gen_history))\n",
    "\n",
    "        pbar.close()\n",
    "\n",
    "        return loss_history"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we use PaddlePaddle to train our model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-01-09T10:52:15.221809Z",
     "start_time": "2021-01-09T10:49:55.308722Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Training: 100%|#################################################| 2250/2250 [00:51<00:00, 43.51it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the density matrix of the target state:\n",
      "[[0.02447175+0.j         0.12500004-0.09081785j]\n",
      " [0.12500004+0.09081785j 0.97552836+0.j        ]] \n",
      "\n",
      "the density matrix of the generated state:\n",
      "[[0.02444273-1.0244548e-08j 0.12302139-9.3332976e-02j]\n",
      " [0.12302142+9.3332976e-02j 0.9755573 +0.0000000e+00j]] \n",
      "\n",
      "the distance between these two quantum states is 2.0483465e-05 \n",
      "\n",
      "the fidelity between these two quantum states is 0.9999945609564611\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# Learning rate\n",
    "LR = 0.1\n",
    "# Total number of iterations\n",
    "ITR = 25\n",
    "# In each iteration, the number of iterations of the discriminator\n",
    "ITR1 = 40\n",
    "# In each iteration, the number of generator iterations\n",
    "ITR2 = 50\n",
    "\n",
    "# prepare the target quantum state\n",
    "target_state = zero_state(num_qubits=3)\n",
    "target_state = RY(0, param=0.9 * np.pi)(target_state)\n",
    "target_state = RZ(0, param=0.2 * np.pi)(target_state)\n",
    "\n",
    "paddle.seed(18)\n",
    "\n",
    "# Construct a QGAN and train\n",
    "gan_demo = QGAN(target_state, LR, ITR, ITR1, ITR2)\n",
    "loss_history = gan_demo.train()\n",
    "\n",
    "# Get the target quantum state\n",
    "target_state = gan_demo.get_target_state()\n",
    "\n",
    "# Get the final quantum state generated by the generator\n",
    "gen_state = gan_demo.get_generated_state()\n",
    "print(\"the density matrix of the target state:\")\n",
    "print(target_state, \"\\n\")\n",
    "print(\"the density matrix of the generated state:\")\n",
    "print(gen_state, \"\\n\")\n",
    "\n",
    "# Calculate the distance between two quantum states,\n",
    "# The distance here is defined as tr[(target_state-gen_state)^2]\n",
    "distance = np.trace(np.matmul(target_state-gen_state, target_state-gen_state)).real\n",
    "# Calculate the fidelity of two quantum states\n",
    "fidelity = np.trace(\n",
    "    scipy.linalg.sqrtm(scipy.linalg.sqrtm(target_state) @ gen_state @ scipy.linalg.sqrtm(gen_state))\n",
    ").real\n",
    "print(\"the distance between these two quantum states is\", distance, \"\\n\")\n",
    "print(\"the fidelity between these two quantum states is\", fidelity)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We compare the target quantum state's density matrix $\\rho_\\text{target}$ and  the generated quantum state's density matrix $\\rho_\\text{gen}$ and calculate the distance between them $\\text{tr}[(\\rho_\\text{target}-\\rho_\\text{gen})^2]$ and fidelity. We can know that our generator generates a quantum state very close to the target state."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualization of the training process"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, let's observe the change of the discriminator and generator's loss curve during the training process.\n",
    "\n",
    "First install the required packages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import clear_output\n",
    "%pip install celluloid\n",
    "clear_output()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we draw the change of the loss curve."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from celluloid import Camera\n",
    "def draw_pic(loss_history):\n",
    "    fig, axes = plt.subplots(nrows=1, ncols=2)\n",
    "    camera = Camera(fig)\n",
    "    axes[0].set_title(\"discriminator\")\n",
    "    axes[0].set_xlabel(\"disc_iter\")\n",
    "    axes[0].set_ylabel(\"disc_loss\")\n",
    "    axes[0].set_xlim(0, 20)\n",
    "    axes[0].set_ylim(-1, 1)\n",
    "    axes[1].set_title(\"generator\")\n",
    "    axes[1].set_xlabel(\"gen_iter\")\n",
    "    axes[1].set_ylabel(\"gen_loss\")\n",
    "    axes[1].set_xlim(0, 50)\n",
    "    axes[1].set_ylim(-1, 0)\n",
    "    for loss in loss_history:\n",
    "        disc_data, gen_data = loss\n",
    "        disc_x_data = range(len(disc_data))\n",
    "        gen_x_data = range(len(gen_data))\n",
    "        axes[0].plot(disc_x_data, disc_data, color='red')\n",
    "        axes[1].plot(gen_x_data, gen_data, color='blue')\n",
    "        camera.snap()\n",
    "    animation = camera.animate(interval=600, \n",
    "                               repeat=True, repeat_delay=800)\n",
    "    animation.save(\"./figures/QGAN-fig-loss.gif\")\n",
    "draw_pic(loss_history)\n",
    "clear_output()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![QGAN-fig-loss](figures/QGAN-fig-loss.gif)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this dynamic picture, each frame represents an iterative process. In an iteration, the red line on the left represents the loss curve of the discriminator, and the blue line on the right represents the loss curve of the generator. It can be seen that at the initial stage, the discriminator and generator can gradually learn from a poor discriminant ability and generation ability to a better discrimination ability and generation ability in the current situation. As the learning progresses, the generator’s generation ability is getting stronger and stronger, and the discriminator’s ability is getting stronger and stronger. However, the discriminator can not distinguish the real data and the generated data because the generator has generated data close to real data. At this time, the model has converged."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_______\n",
    "\n",
    "## References"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[1] Goodfellow, I. J. et al. Generative Adversarial Nets. [Proc. 27th Int. Conf. Neural Inf. Process. Syst. (2014).](https://papers.nips.cc/paper/5423-generative-adversarial-nets)\n",
    "\n",
    "[2] Lloyd, S. & Weedbrook, C. Quantum Generative Adversarial Learning. [Phys. Rev. Lett. 121, 040502 (2018).](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.121.040502)\n",
    "\n",
    "[3] Benedetti, M., Grant, E., Wossnig, L. & Severini, S. Adversarial quantum circuit learning for pure state approximation. [New J. Phys. 21, (2019).](https://iopscience.iop.org/article/10.1088/1367-2630/ab14b5)\n"
   ]
  }
 ],
 "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.13"
  },
  "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
}