QClassifier_EN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quantum Classifier\n",
    "\n",
    "<em> Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. </em>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Overview\n",
    "\n",
    "In this tutorial, we will discuss the workflow of Variational Quantum Classifiers (VQC) and how to use quantum neural networks (QNN) to accomplish a **binary classification** task. The main representatives of this approach include the [Quantum Circuit Learning (QCL)](https://arxiv.org/abs/1803.00745) [1] by Mitarai et al. (2018), Farhi & Neven (2018) [2] and [Circuit-Centric Quantum Classifiers](https://arxiv.org/abs/1804.00633) [3] by Schuld et al. (2018). Here, we mainly talk about classification in the language of supervised learning. Unlike classical methods, quantum classifiers require pre-processing to encode classical data into quantum data, and then train the parameters in the quantum neural network. Using different encoding methods, we can benchmark the optimal classification performance through test data. Finally, we demonstrate how to use built-in quantum datasets to accomplish quantum classification.\n",
    "\n",
    "### Background\n",
    "\n",
    "In the language of supervised learning, we need to enter a data set composed of $N$ pairs of labeled data points $D = \\{(x^k,y^k)\\}_{k=1}^{N}$ , Where $x^k\\in \\mathbb{R}^{m}$ is the data point, and $y^k \\in\\{0,1\\}$ is the label associated with the data point $x^k$. **The classification process is essentially a decision-making process, which determines the label attribution of a given data point**. For the quantum classifier framework, the realization of the classifier $\\mathcal{F}$ is a combination of a quantum neural network (or parameterized quantum circuit) with parameters $\\theta$, measurement, and data processing. An excellent classifier $\\mathcal{F}_\\theta$ should correctly map the data points in each data set to the corresponding labels as accurate as possible $\\mathcal{F}_\\theta(x^k ) \\rightarrow y^k$. Therefore, we use the cumulative distance between the predicted label $\\tilde{y}^{k} = \\mathcal{F}_\\theta(x^k)$ and the actual label $y^k$ as the loss function $\\mathcal {L}(\\theta)$ to be optimized. For binary classification tasks, we can choose the following loss function,\n",
    "\n",
    "$$\n",
    "\\mathcal{L}(\\theta) = \\sum_{k=1}^N 1/N \\cdot |\\tilde{y}^{k}-y^k|^2. \\tag{1}\n",
    "$$\n",
    "\n",
    "### Pipeline\n",
    "\n",
    "Here we give the whole pipeline to implement a quantum classifier under the framework of quantum circuit learning (QCL).\n",
    "\n",
    "1. Encode the classical data $x^k$ to quantum data $\\lvert \\psi_{\\rm in}\\rangle^k$. In this tutorial, we use Angle Encoding, see [encoding methods](./DataEncoding_EN.ipynb) for details. Readers can also try other encoding methods, e.g., Amplitude Encoding, and see the performance.\n",
    "2. Construct the parameterized quantum circuit (PQC), corresponds to the unitary gate $U(\\theta)$.\n",
    "3. Apply the parameterized circuit $U(\\theta)$ with the parameter $\\theta$ on input states $\\lvert \\psi_{\\rm in} \\rangle^k$, thereby obtaining the output state $\\lvert \\psi_{\\rm out} \\rangle^k = U(\\theta)\\lvert \\psi_{\\rm in} \\rangle^k$.\n",
    "4. Measure the quantum state $\\lvert \\psi_{\\rm out}\\rangle^k$ processed by the quantum neural network to get the estimated label $\\tilde{y}^{k}$.\n",
    "5. Repeat steps 3-4 until all data points in the data set have been processed. Then calculate the loss function $\\mathcal{L}(\\theta)$.\n",
    "6. Continuously adjust the parameter $\\theta$ through optimization methods such as gradient descent to minimize the loss function. Record the optimal parameters after optimization $\\theta^* $, and then we obtain the optimal classifier $\\mathcal{F}_{\\theta^*}$.\n",
    "\n",
    "<img src=\"./figures/qclassifier-fig-pipeline.png\" width=\"700px\" /> \n",
    "<center> Figure 1: Flow chart of quantum classifier training </center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Paddle Quantum Implementation\n",
    "\n",
    "Here, we first import the required packages:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\yeruilin\\Anaconda3\\envs\\paddle_quantum_env\\lib\\site-packages\\matplotlib_inline\\config.py:66: DeprecationWarning: InlineBackend._figure_formats_changed is deprecated in traitlets 4.1: use @observe and @unobserve instead.\n",
      "  def _figure_formats_changed(self, name, old, new):\n"
     ]
    }
   ],
   "source": [
    "# Import numpy and paddle\n",
    "import numpy as np\n",
    "import paddle\n",
    "\n",
    "# To construct quantum circuit\n",
    "from paddle_quantum.circuit import UAnsatz\n",
    "# Some functions\n",
    "from numpy import pi as PI\n",
    "from paddle import matmul, transpose, reshape  # paddle matrix multiplication and transpose\n",
    "from paddle_quantum.utils import pauli_str_to_matrix, dagger  # N qubits Pauli matrix, complex conjugate\n",
    "\n",
    "# Plot figures, calculate the run time\n",
    "from matplotlib import pyplot as plt\n",
    "import time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parameters used for classification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parameters for generating the data set\n",
    "Ntrain = 200        # Specify the training set size\n",
    "Ntest = 100         # Specify the test set size\n",
    "boundary_gap = 0.5  # Set the width of the decision boundary\n",
    "seed_data = 2       # Fixed random seed required to generate the data set\n",
    "# Parameters for training\n",
    "N = 4               # Number of qubits required\n",
    "DEPTH = 1           # Circuit depth\n",
    "BATCH = 20          # Batch size during training\n",
    "EPOCH = int(200 * BATCH / Ntrain)\n",
    "                    # Number of training epochs, the total iteration number \"EPOCH * (Ntrain / BATCH)\" is chosen to be about 200\n",
    "LR = 0.01           # Set the learning rate\n",
    "seed_paras = 19     # Set random seed to initialize various parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data set generation\n",
    "\n",
    "One of the key parts in supervised learning is what data set to use? In this tutorial, we follow the exact approach introduced in QCL paper to generate a simple binary data set $\\{(x^{k}, y^{k})\\}$ with circular decision boundary, where the data point $x^{k}\\in \\mathbb{R}^{2}$, and the label $y^{k} \\in \\{0,1\\}$. The figure below provides us a concrete example.\n",
    "\n",
    "<img src=\"./figures/qclassifier-fig-data.png\" width=\"400px\" /> \n",
    "<center> Figure 2: Generated data set and the corresponding decision boundary </center>\n",
    "\n",
    "For the generation method and visualization, please see the following code:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generate a binary classification data set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T04:03:35.707224Z",
     "start_time": "2021-03-09T04:03:35.691351Z"
    }
   },
   "outputs": [],
   "source": [
    "# Generate a binary classification data set with circular decision boundary\n",
    "def circle_data_point_generator(Ntrain, Ntest, boundary_gap, seed_data):\n",
    "    \"\"\"\n",
    "    :param Ntrain: number of training samples\n",
    "    :param Ntest: number of test samples\n",
    "    :param boundary_gap: value in (0, 0.5), means the gap between two labels\n",
    "    :param seed_data: random seed\n",
    "    :return: 'Ntrain' samples for training and\n",
    "             'Ntest' samples for testing\n",
    "    \"\"\"\n",
    "    # Generate \"Ntrain + Ntest\" pairs of data, x for 2-dim data points, y for labels.\n",
    "    # The first \"Ntrain\" pairs are used as training set, the last \"Ntest\" pairs are used as testing set\n",
    "    train_x, train_y = [], []\n",
    "    num_samples, seed_para = 0, 0\n",
    "    while num_samples < Ntrain + Ntest:\n",
    "        np.random.seed((seed_data + 10) * 1000 + seed_para + num_samples)\n",
    "        data_point = np.random.rand(2) * 2 - 1  # 2-dim vector in range [-1, 1]\n",
    "\n",
    "        # If the modulus of the data point is less than (0.7 - gap), mark it as 0\n",
    "        if np.linalg.norm(data_point) < 0.7-boundary_gap / 2:\n",
    "            train_x.append(data_point)\n",
    "            train_y.append(0.)\n",
    "            num_samples += 1\n",
    "\n",
    "        # If the modulus of the data point is greater than (0.7 + gap), mark it as 1\n",
    "        elif np.linalg.norm(data_point) > 0.7 + boundary_gap / 2:\n",
    "            train_x.append(data_point)\n",
    "            train_y.append(1.)\n",
    "            num_samples += 1\n",
    "        else:\n",
    "            seed_para += 1\n",
    "\n",
    "    train_x = np.array(train_x).astype(\"float64\")\n",
    "    train_y = np.array([train_y]).astype(\"float64\").T\n",
    "\n",
    "    print(\"The dimensions of the training set x {} and y {}\".format(np.shape(train_x[0:Ntrain]), np.shape(train_y[0:Ntrain])))\n",
    "    print(\"The dimensions of the test set x {} and y {}\".format(np.shape(train_x[Ntrain:]), np.shape(train_y[Ntrain:])), \"\\n\")\n",
    "\n",
    "    return train_x[0:Ntrain], train_y[0:Ntrain], train_x[Ntrain:], train_y[Ntrain:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Visualize the generated data set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def data_point_plot(data, label):\n",
    "    \"\"\"\n",
    "    :param data: shape [M, 2], means M 2-D data points\n",
    "    :param label: value 0 or 1\n",
    "    :return: plot these data points\n",
    "    \"\"\"\n",
    "    dim_samples, dim_useless = np.shape(data)\n",
    "    plt.figure(1)\n",
    "    for i in range(dim_samples):\n",
    "        if label[i] == 0:\n",
    "            plt.plot(data[i][0], data[i][1], color=\"r\", marker=\"o\")\n",
    "        elif label[i] == 1:\n",
    "            plt.plot(data[i][0], data[i][1], color=\"b\", marker=\"o\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this tutorial, we use a training set with 200 elements, a testing set with 100 elements. The boundary gap is 0.5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T04:03:37.244233Z",
     "start_time": "2021-03-09T04:03:35.719425Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The dimensions of the training set x (200, 2) and y (200, 1)\n",
      "The dimensions of the test set x (100, 2) and y (100, 1) \n",
      "\n",
      "Visualization of 200 data points in the training set: \n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Visualization of 100 data points in the test set: \n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " You may wish to adjust the parameter settings to generate your own data set!\n"
     ]
    }
   ],
   "source": [
    "# Generate data set\n",
    "train_x, train_y, test_x, test_y = circle_data_point_generator(\n",
    "        Ntrain, Ntest, boundary_gap, seed_data)\n",
    "\n",
    "# Visualization\n",
    "print(\"Visualization of {} data points in the training set: \".format(Ntrain))\n",
    "data_point_plot(train_x, train_y)\n",
    "print(\"Visualization of {} data points in the test set: \".format(Ntest))\n",
    "data_point_plot(test_x, test_y)\n",
    "print(\"\\n You may wish to adjust the parameter settings to generate your own data set!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data preprocessing\n",
    "Different from classical machine learning, quantum classifiers need to consider data preprocessing heavily. We need one more step to convert classical data into quantum information before running on a quantum computer. In this tutorial we use \"Angle Encoding\" to get quantum data.\n",
    "\n",
    "First, we determine the number of qubits that need to be used. Because our data $\\{x^{k} = (x^{k}_0, x^{k}_1)\\}$ is two-dimensional, according to the paper by Mitarai (2018) we need at least 2 qubits for encoding. Then prepare a group of initial quantum states $|00\\rangle$. Encode the classical information $\\{x^{k}\\}$ into a group of quantum gates $U(x^{k})$ and act them on the initial quantum states. Finally we get a group of quantum states $|\\psi_{\\rm in}\\rangle^k = U(x^{k})|00\\rangle$. In this way, we have completed the encoding from classical information into quantum information! Given $m$ qubits to encode a two-dimensional classical data point, the quantum gate is:\n",
    "\n",
    "$$\n",
    "U(x^{k}) = \\otimes_{j=0}^{m-1} R_j^z\\big[\\arccos(x^{k}_{j \\, \\text{mod} \\, 2}\\cdot x^{k}_{j \\, \\text{mod} \\, 2})\\big] R_j^y\\big[\\arcsin(x^{k}_{j \\, \\text{mod} \\, 2}) \\big],\n",
    "\\tag{2}\n",
    "$$\n",
    "\n",
    "**Note:** In this representation, we count the first qubit as $j = 0$. For more encoding methods, see [Robust data encodings for quantum classifiers](https://arxiv.org/pdf/2003.01695.pdf). We also provide several built-in [encoding methods](./DataEncoding_EN.ipynb) in Paddle Quantum. Here we also encourage readers to try new encoding methods by themselves!\n",
    "\n",
    "Since this encoding method looks quite complicated, we might as well give a simple example. Suppose we are given a data point $x = (x_0, x_1)= (1,0)$. The label of this data point should be 1, corresponding to the **blue** point in the figure above. At the same time, the 2-qubit quantum gate $U(x)$ corresponding to the data point is,\n",
    "\n",
    "$$\n",
    "U(x) =\n",
    "\\bigg( R_0^z\\big[\\arccos(x_{0}\\cdot x_{0})\\big] R_0^y\\big[\\arcsin(x_{0}) \\big] \\bigg)\n",
    "\\otimes\n",
    "\\bigg( R_1^z\\big[\\arccos(x_{1}\\cdot x_{1})\\big] R_1^y\\big[\\arcsin(x_{1}) \\big] \\bigg),\n",
    "\\tag{3}\n",
    "$$\n",
    "\n",
    "Substituting in specific values, we get:\n",
    "\n",
    "$$\n",
    "U(x) =\n",
    "\\bigg( R_0^z\\big[0\\big] R_0^y\\big[\\pi/2 \\big] \\bigg)\n",
    "\\otimes\n",
    "\\bigg( R_1^z\\big[\\pi/2\\big] R_1^y\\big[0 \\big] \\bigg),\n",
    "\\tag{4}\n",
    "$$\n",
    "\n",
    "Recall the matrix form of rotation gates:\n",
    "\n",
    "$$\n",
    "R_x(\\theta) :=\n",
    "\\begin{bmatrix}\n",
    "\\cos \\frac{\\theta}{2} &-i\\sin \\frac{\\theta}{2} \\\\\n",
    "-i\\sin \\frac{\\theta}{2} &\\cos \\frac{\\theta}{2}\n",
    "\\end{bmatrix}\n",
    ",\\quad\n",
    "R_y(\\theta) :=\n",
    "\\begin{bmatrix}\n",
    "\\cos \\frac{\\theta}{2} &-\\sin \\frac{\\theta}{2} \\\\\n",
    "\\sin \\frac{\\theta}{2} &\\cos \\frac{\\theta}{2}\n",
    "\\end{bmatrix}\n",
    ",\\quad\n",
    "R_z(\\theta) :=\n",
    "\\begin{bmatrix}\n",
    "e^{-i\\frac{\\theta}{2}} & 0 \\\\\n",
    "0 & e^{i\\frac{\\theta}{2}}\n",
    "\\end{bmatrix}.\n",
    "\\tag{5}\n",
    "$$\n",
    "\n",
    "Then the matrix form of the two-qubit quantum gate $U(x)$ can be written as\n",
    "\n",
    "$$\n",
    "U(x) = \n",
    "\\bigg(\n",
    "\\begin{bmatrix}\n",
    "1 & 0 \\\\ \n",
    "0 & 1\n",
    "\\end{bmatrix}\n",
    "\\begin{bmatrix}\n",
    "\\cos \\frac{\\pi}{4} &-\\sin \\frac{\\pi}{4} \\\\ \n",
    "\\sin \\frac{\\pi}{4} &\\cos \\frac{\\pi}{4} \n",
    "\\end{bmatrix}\n",
    "\\bigg)\n",
    "\\otimes \n",
    "\\bigg(\n",
    "\\begin{bmatrix}\n",
    "e^{-i\\frac{\\pi}{4}} & 0 \\\\ \n",
    "0 & e^{i\\frac{\\pi}{4}}\n",
    "\\end{bmatrix}\n",
    "\\begin{bmatrix}\n",
    "1 &0 \\\\ \n",
    "0 &1\n",
    "\\end{bmatrix}\n",
    "\\bigg) \\, .\n",
    "\\tag{6}\n",
    "$$\n",
    "\n",
    "After simplification, we can get the encoded quantum state $|\\psi_{\\rm in}\\rangle$ by acting the quantum gate on the initialized quantum state $|00\\rangle$,\n",
    "\n",
    "$$\n",
    "|\\psi_{\\rm in}\\rangle =\n",
    "U(x)|00\\rangle = \\frac{1}{2}\n",
    "\\begin{bmatrix}\n",
    "1-i &0 &-1+i &0 \\\\\n",
    "0 &1+i &0 &-1-i \\\\\n",
    "1-i &0 &1-i &0 \\\\\n",
    "0 &1+i &0 &1+i\n",
    "\\end{bmatrix}\n",
    "\\begin{bmatrix}\n",
    "1 \\\\\n",
    "0 \\\\\n",
    "0 \\\\\n",
    "0\n",
    "\\end{bmatrix}\n",
    "= \\frac{1}{2}\n",
    "\\begin{bmatrix}\n",
    "1-i \\\\\n",
    "0 \\\\\n",
    "1-i \\\\\n",
    "0\n",
    "\\end{bmatrix}.\n",
    "\\tag{7}\n",
    "$$\n",
    "\n",
    "Then let us take a look at how to implement this encoding method in Paddle Quantum. Note that in the code, we use the following trick: \n",
    "\n",
    "$$\n",
    "(U_1 |0\\rangle)\\otimes (U_2 |0\\rangle) = (U_1 \\otimes U_2) |0\\rangle\\otimes|0\\rangle\n",
    "= (U_1 \\otimes U_2) |00\\rangle.\n",
    "\\tag{8}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T04:03:37.354267Z",
     "start_time": "2021-03-09T04:03:37.258314Z"
    }
   },
   "outputs": [],
   "source": [
    "# Gate: rotate around Y-axis, Z-axis with angle theta\n",
    "def Ry(theta):\n",
    "    \"\"\"\n",
    "    :param theta: parameter\n",
    "    :return: Y rotation matrix\n",
    "    \"\"\"\n",
    "    return np.array([[np.cos(theta / 2), -np.sin(theta / 2)],\n",
    "                     [np.sin(theta / 2), np.cos(theta / 2)]])\n",
    "\n",
    "def Rz(theta):\n",
    "    \"\"\"\n",
    "    :param theta: parameter\n",
    "    :return: Z rotation matrix\n",
    "    \"\"\"\n",
    "    return np.array([[np.cos(theta / 2) - np.sin(theta / 2) * 1j, 0],\n",
    "                     [0, np.cos(theta / 2) + np.sin(theta / 2) * 1j]])\n",
    "\n",
    "# Classical -> Quantum Data Encoder\n",
    "def datapoints_transform_to_state(data, n_qubits):\n",
    "    \"\"\"\n",
    "    :param data: shape [-1, 2]\n",
    "    :param n_qubits: the number of qubits to which\n",
    "    the data transformed\n",
    "    :return: shape [-1, 1, 2 ^ n_qubits]\n",
    "        the first parameter -1 in this shape means can be arbitrary. In this tutorial, it equals to BATCH.\n",
    "    \"\"\"\n",
    "    dim1, dim2 = data.shape\n",
    "    res = []\n",
    "    for sam in range(dim1):\n",
    "        res_state = 1.\n",
    "        zero_state = np.array([[1, 0]])\n",
    "        # Angle Encoding\n",
    "        for i in range(n_qubits):\n",
    "            # For even number qubits, perform Rz(arccos(x0^2)) Ry(arcsin(x0))\n",
    "            if i % 2 == 0:\n",
    "                state_tmp=np.dot(zero_state, Ry(np.arcsin(data[sam][0])).T)\n",
    "                state_tmp=np.dot(state_tmp, Rz(np.arccos(data[sam][0] ** 2)).T)\n",
    "                res_state=np.kron(res_state, state_tmp)\n",
    "            # For odd number qubits, perform Rz(arccos(x1^2)) Ry(arcsin(x1))\n",
    "            elif i% 2 == 1:\n",
    "                state_tmp=np.dot(zero_state, Ry(np.arcsin(data[sam][1])).T)\n",
    "                state_tmp=np.dot(state_tmp, Rz(np.arccos(data[sam][1] ** 2)).T)\n",
    "                res_state=np.kron(res_state, state_tmp)\n",
    "        res.append(res_state)\n",
    "    res = np.array(res)\n",
    "\n",
    "    return res.astype(\"complex128\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "quantum data after angle encoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "As a test, we enter the classical information:\n",
      "(x_0, x_1) = (1, 0)\n",
      "The 2-qubit quantum state output after encoding is:\n",
      "[[[0.5-0.5j 0. +0.j  0.5-0.5j 0. +0.j ]]]\n"
     ]
    }
   ],
   "source": [
    "print(\"As a test, we enter the classical information:\")\n",
    "print(\"(x_0, x_1) = (1, 0)\")\n",
    "print(\"The 2-qubit quantum state output after encoding is:\")\n",
    "print(datapoints_transform_to_state(np.array([[1, 0]]), n_qubits=2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building Quantum Neural Network \n",
    "After completing the encoding from classical data to quantum data, we can now input these quantum states into the quantum computer. Before that, we also need to design the quantum neural network.\n",
    "\n",
    "<img src=\"./figures/qclassifier-fig-circuit.png\" width=\"600px\" /> \n",
    "<center> Figure 3: Parameterized Quantum Circuit </center>\n",
    "\n",
    "\n",
    "For convenience, we call the parameterized quantum neural network as $U(\\boldsymbol{\\theta})$. $U(\\boldsymbol{\\theta})$ is a key component of our classifier, and it needs a certain complex structure to fit our decision boundary. Similar to traditional neural networks, the structure of a quantum neural network is not unique. The structure shown above is just one case. You could design your own structure. Let's take the previously mentioned data point $x = (x_0, x_1)= (1,0)$ as an example. After encoding, we have obtained a quantum state $|\\psi_{\\rm in}\\rangle$,\n",
    "\n",
    "$$\n",
    "|\\psi_{\\rm in}\\rangle =\n",
    "\\frac{1}{2}\n",
    "\\begin{bmatrix}\n",
    "1-i \\\\\n",
    "0 \\\\\n",
    "1-i \\\\\n",
    "0\n",
    "\\end{bmatrix}.\n",
    "\\tag{9}\n",
    "$$\n",
    "\n",
    "Then we input this quantum state into our quantum neural network (QNN). That is, multiply a unitary matrix by a vector to get the processed quantum state $|\\varphi\\rangle$\n",
    "\n",
    "$$\n",
    "|\\psi_{\\rm out}\\rangle = U(\\boldsymbol{\\theta})|\\psi_{\\rm in}\\rangle.\n",
    "\\tag{10}\n",
    "$$\n",
    "\n",
    "If we set all the QNN parameters to be $\\theta = \\pi$, then we can write down the resulting state:\n",
    "\n",
    "$$\n",
    "|\\psi_{\\rm out}\\rangle =\n",
    "U(\\boldsymbol{\\theta} =\\pi)|\\psi_{\\rm in}\\rangle =\n",
    "\\begin{bmatrix}\n",
    "0 &0 &-1 &0 \\\\\n",
    "-1 &0 &0 &0 \\\\\n",
    "0 &1 &0 &0 \\\\\n",
    "0 &0 &0 &1\n",
    "\\end{bmatrix}\n",
    "\\cdot\n",
    "\\frac{1}{2}\n",
    "\\begin{bmatrix}\n",
    "1-i \\\\\n",
    "0 \\\\\n",
    "1-i \\\\\n",
    "0\n",
    "\\end{bmatrix}\n",
    "= \\frac{1}{2}\n",
    "\\begin{bmatrix}\n",
    "-1+i \\\\\n",
    "-1+i \\\\\n",
    "0 \\\\\n",
    "0\n",
    "\\end{bmatrix}.\n",
    "\\tag{11}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T04:03:37.426687Z",
     "start_time": "2021-03-09T04:03:37.374976Z"
    }
   },
   "outputs": [],
   "source": [
    "# Simulation of building a quantum neural network\n",
    "def cir_Classifier(theta, n, depth):\n",
    "    \"\"\"\n",
    "    :param theta: dim: [n, depth + 3], \"+3\" because we add an initial generalized rotation gate to each qubit\n",
    "    :param n: number of qubits\n",
    "    :param depth: circuit depth\n",
    "    :return: U_theta\n",
    "    \"\"\"\n",
    "    # Initialize the network\n",
    "    cir = UAnsatz(n)\n",
    "    \n",
    "    # Build a generalized rotation layer\n",
    "    for i in range(n):\n",
    "        cir.rz(theta[i][0], i)\n",
    "        cir.ry(theta[i][1], i)\n",
    "        cir.rz(theta[i][2], i)\n",
    "\n",
    "    # The default depth is depth = 1\n",
    "    # Build the entangleed layer and Ry rotation layer\n",
    "    for d in range(3, depth + 3):\n",
    "        # The entanglement layer\n",
    "        for i in range(n-1):\n",
    "            cir.cnot([i, i + 1])\n",
    "        cir.cnot([n-1, 0])\n",
    "        # Add Ry to each qubit\n",
    "        for i in range(n):\n",
    "            cir.ry(theta[i][d], i)\n",
    "\n",
    "    return cir"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Measurement\n",
    "After passing through the PQC $U(\\theta)$, the quantum data becomes $\\lvert \\psi_{\\rm out}\\rangle^k = U(\\theta)\\lvert \\psi_{\\rm in} \\rangle^k$. To get its label, we need to measure this new quantum state to obtain the classical information. These processed classical information will then be used to calculate the loss function $\\mathcal{L}(\\boldsymbol{\\theta})$. Finally, based on the gradient descent algorithm, we continuously update the PQC parameters $\\boldsymbol{\\theta}$ and optimize the loss function. \n",
    "\n",
    "Here we measure the expected value of the Pauli $Z$ operator on the first qubit. Specifically,\n",
    "\n",
    "$$\n",
    "\\langle Z \\rangle =\n",
    "\\langle \\psi_{\\rm out} |Z\\otimes I\\cdots \\otimes I| \\psi_{\\rm out}\\rangle.\n",
    "\\tag{12}\n",
    "$$\n",
    "\n",
    "Recall that the matrix of the Pauli $Z$ operator is defined as:\n",
    "\n",
    "$$\n",
    "Z := \\begin{bmatrix} 1 &0 \\\\ 0 &-1 \\end{bmatrix}.\n",
    "\\tag{13}\n",
    "$$\n",
    "\n",
    "Continuing our previous 2-qubit example, the expected value we get after the measurement is\n",
    "\n",
    "$$\n",
    "\\langle Z \\rangle =\n",
    "\\langle \\psi_{\\rm out} |Z\\otimes I| \\psi_{\\rm out}\\rangle =\n",
    "\\frac{1}{2}\n",
    "\\begin{bmatrix}\n",
    "-1-i \\quad\n",
    "-1-i \\quad\n",
    "0 \\quad\n",
    "0\n",
    "\\end{bmatrix}\n",
    "\\begin{bmatrix}\n",
    "1 &0 &0 &0 \\\\\n",
    "0 &1 &0 &0 \\\\\n",
    "0 &0 &-1 &0 \\\\\n",
    "0 &0 &0 &-1\n",
    "\\end{bmatrix}\n",
    "\\cdot\n",
    "\\frac{1}{2}\n",
    "\\begin{bmatrix}\n",
    "-1+i \\\\\n",
    "-1+i \\\\\n",
    "0 \\\\\n",
    "0\n",
    "\\end{bmatrix}\n",
    "= 1. \\tag{14}\n",
    "$$\n",
    "\n",
    "This measurement result seems to be our original label 1. Does this mean that we have successfully classified this data point? This is not the case because the range of $\\langle Z \\rangle$ is usually between $[-1,1]$. \n",
    "To match it to our label range $y^{k} \\in \\{0,1\\}$, we need to map the upper and lower limits. The simplest mapping is \n",
    "\n",
    "$$\n",
    "\\tilde{y}^{k} = \\frac{\\langle Z \\rangle}{2} + \\frac{1}{2} + bias \\quad \\in [0, 1].\n",
    "\\tag{15}\n",
    "$$\n",
    "\n",
    "Using bias is a trick in machine learning. The purpose is to make the decision boundary not restricted by the origin or some hyperplane. Generally, the default bias is initialized to be 0, and the optimizer will continuously update it like all the other parameters $\\theta$ in the iterative process to ensure $\\tilde{y}^{k} \\in [0, 1]$. Of course, you can also choose other complex mappings (activation functions), such as the sigmoid function. After mapping, we can regard $\\tilde{y}^{k}$ as the label we estimated. $\\tilde{y}^{k}< 0.5$ corresponds to label 0, and $\\tilde{y}^{k}> 0.5$ corresponds to label 1. It's time to quickly review the whole process before we finish discussion,\n",
    "\n",
    "$$\n",
    "x^{k} \\rightarrow |\\psi_{\\rm in}\\rangle^{k} \\rightarrow U(\\boldsymbol{\\theta})|\\psi_{\\rm in}\\rangle^{k} \\rightarrow\n",
    "|\\psi_{\\rm out}\\rangle^{k} \\rightarrow ^{k}\\langle \\psi_{\\rm out} |Z\\otimes I\\cdots \\otimes I| \\psi_{\\rm out} \\rangle^{k}\n",
    "\\rightarrow \\langle Z \\rangle  \\rightarrow \\tilde{y}^{k}.\\tag{16}\n",
    "$$\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Loss function\n",
    "\n",
    "To calculate the loss function in Eq. (1), we need to measure all training data in each iteration. In real practice, we devide the training data into \"Ntrain/BATCH\" groups, where each group contains \"BATCH\" data pairs.\n",
    "\n",
    "The loss function for the i-th group is \n",
    "$$\n",
    "\\mathcal{L}_{i} = \\sum_{k=1}^{BATCH} \\frac{1}{BATCH} |y^{i,k} - \\tilde{y}^{i,k}|^2,\\tag{17}\n",
    "$$\n",
    "and we train the PQC with $\\mathcal{L}_{i}$ for \"EPOCH\" times. \n",
    "\n",
    "If you set \"BATCH = Ntrain\", there will be only one group, and Eq. (17) becomes Eq. (1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T04:03:37.439183Z",
     "start_time": "2021-03-09T04:03:37.432202Z"
    }
   },
   "outputs": [],
   "source": [
    "# Generate Pauli Z operator that only acts on the first qubit\n",
    "# Act the identity matrix on rest of the qubits\n",
    "def Observable(n):\n",
    "    r\"\"\"\n",
    "    :param n: number of qubits\n",
    "    :return: local observable: Z \\otimes I \\otimes ...\\otimes I\n",
    "    \"\"\"\n",
    "    Ob = pauli_str_to_matrix([[1.0,'z0']], n)\n",
    "\n",
    "    return Ob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T04:03:37.503213Z",
     "start_time": "2021-03-09T04:03:37.473028Z"
    }
   },
   "outputs": [],
   "source": [
    "# Build the computational graph\n",
    "class Opt_Classifier(paddle.nn.Layer):\n",
    "    \"\"\"\n",
    "    Construct the model net\n",
    "    \"\"\"\n",
    "    def __init__(self, n, depth, seed_paras=1, dtype='float64'):\n",
    "        # Initialization, use n, depth give the initial PQC\n",
    "        super(Opt_Classifier, self).__init__()\n",
    "        self.n = n\n",
    "        self.depth = depth\n",
    "        # Initialize the parameters theta with a uniform distribution of [0, 2*pi]\n",
    "        self.theta = self.create_parameter(\n",
    "            shape=[n, depth + 3],  # \"+3\" because we add an initial generalized rotation gate to each qubit\n",
    "            default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*PI),\n",
    "            dtype=dtype,\n",
    "            is_bias=False)\n",
    "        # Initialize bias\n",
    "        self.bias = self.create_parameter(\n",
    "            shape=[1],\n",
    "            default_initializer=paddle.nn.initializer.Normal(std=0.01),\n",
    "            dtype=dtype,\n",
    "            is_bias=False)\n",
    "\n",
    "    # Define forward propagation mechanism, and then calculate loss function and cross-validation accuracy\n",
    "    def forward(self, state_in, label):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            state_in: The input quantum state, shape [-1, 1, 2^n] -- in this tutorial: [BATCH, 1, 2^n]\n",
    "            label: label for the input state, shape [-1, 1]\n",
    "        Returns:\n",
    "            The loss:\n",
    "                L = 1/BATCH * ((<Z> + 1)/2 + bias - label)^2\n",
    "        \"\"\"\n",
    "        # Convert Numpy array to tensor\n",
    "        Ob = paddle.to_tensor(Observable(self.n))\n",
    "        label_pp = reshape(paddle.to_tensor(label), [-1, 1])\n",
    "\n",
    "        # Build the quantum circuit\n",
    "        cir = cir_Classifier(self.theta, n=self.n, depth=self.depth)\n",
    "        Utheta = cir.U\n",
    "\n",
    "        # Because Utheta is achieved by learning, we compute with row vectors to speed up without affecting the training effect\n",
    "        state_out = matmul(state_in, Utheta)  # shape:[-1, 1, 2 ** n], the first parameter is BATCH in this tutorial\n",
    "\n",
    "        # Measure the expectation value of Pauli Z operator <Z> -- shape [-1,1,1]\n",
    "        E_Z = matmul(matmul(state_out, Ob), transpose(paddle.conj(state_out), perm=[0, 2, 1]))\n",
    "\n",
    "        # Mapping <Z> to the estimated value of the label\n",
    "        state_predict = paddle.real(E_Z)[:, 0] * 0.5 + 0.5 + self.bias  # |y^{i,k} - \\tilde{y}^{i,k}|^2\n",
    "        loss = paddle.mean((state_predict - label_pp) ** 2)  # Get average for \"BATCH\" |y^{i,k} - \\tilde{y}^{i,k}|^2: L_i：shape:[1,1]\n",
    "\n",
    "        # Calculate the accuracy of cross-validation\n",
    "        is_correct = (paddle.abs(state_predict - label_pp) < 0.5).nonzero().shape[0]\n",
    "        acc = is_correct / label.shape[0]\n",
    "\n",
    "        return loss, acc, state_predict.numpy(), cir"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training process\n",
    "\n",
    "After defining all the concepts above, we might take a look at the actual training process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Draw the figure of the final training classifier\n",
    "def heatmap_plot(Opt_Classifier, N):\n",
    "    # generate data points x_y_\n",
    "    Num_points = 30\n",
    "    x_y_ = []\n",
    "    for row_y in np.linspace(0.9, -0.9, Num_points):\n",
    "        row = []\n",
    "        for row_x in np.linspace(-0.9, 0.9, Num_points):\n",
    "            row.append([row_x, row_y])\n",
    "        x_y_.append(row)\n",
    "    x_y_ = np.array(x_y_).reshape(-1, 2).astype(\"float64\")\n",
    "\n",
    "    # make prediction: heat_data\n",
    "    input_state_test = paddle.to_tensor(\n",
    "        datapoints_transform_to_state(x_y_, N))\n",
    "    loss_useless, acc_useless, state_predict, cir = Opt_Classifier(state_in=input_state_test, label=x_y_[:, 0])\n",
    "    heat_data = state_predict.reshape(Num_points, Num_points)\n",
    "\n",
    "    # plot\n",
    "    fig = plt.figure(1)\n",
    "    ax = fig.add_subplot(111)\n",
    "    x_label = np.linspace(-0.9, 0.9, 3)\n",
    "    y_label = np.linspace(0.9, -0.9, 3)\n",
    "    ax.set_xticks([0, Num_points // 2, Num_points - 1])\n",
    "    ax.set_xticklabels(x_label)\n",
    "    ax.set_yticks([0, Num_points // 2, Num_points - 1])\n",
    "    ax.set_yticklabels(y_label)\n",
    "    im = ax.imshow(heat_data, cmap=plt.cm.RdBu)\n",
    "    plt.colorbar(im)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Learn the PQC via Adam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T04:03:38.325454Z",
     "start_time": "2021-03-09T04:03:38.299975Z"
    }
   },
   "outputs": [],
   "source": [
    "def QClassifier(Ntrain, Ntest, gap, N, DEPTH, EPOCH, LR, BATCH, seed_paras, seed_data):\n",
    "    \"\"\"\n",
    "    Quantum Binary Classifier\n",
    "    Input:\n",
    "        Ntrain         # Specify the training set size\n",
    "        Ntest          # Specify the test set size\n",
    "        gap            # Set the width of the decision boundary\n",
    "        N              # Number of qubits required\n",
    "        DEPTH          # Circuit depth\n",
    "        BATCH          # Batch size during training\n",
    "        EPOCH          # Number of training epochs, the total iteration number \"EPOCH * (Ntrain / BATCH)\" is chosen to be about 200\n",
    "        LR             # Set the learning rate\n",
    "        seed_paras     # Set random seed to initialize various parameters\n",
    "        seed_data      # Fixed random seed required to generate the data set\n",
    "        plot_heat_map  # Whether to plot heat map, default True\n",
    "    \"\"\"\n",
    "    # Generate data set\n",
    "    train_x, train_y, test_x, test_y = circle_data_point_generator(Ntrain=Ntrain, Ntest=Ntest, boundary_gap=gap, seed_data=seed_data)\n",
    "    # Read the dimension of the training set\n",
    "    N_train = train_x.shape[0]\n",
    "    \n",
    "    paddle.seed(seed_paras)\n",
    "    # Initialize the registers to store the accuracy rate and other information\n",
    "    summary_iter, summary_test_acc = [], []\n",
    "\n",
    "    # Generally, we use Adam optimizer to get relatively good convergence\n",
    "    # Of course, it can be changed to SGD or RMSprop\n",
    "    myLayer = Opt_Classifier(n=N, depth=DEPTH)  # Initial PQC\n",
    "    opt = paddle.optimizer.Adam(learning_rate=LR, parameters=myLayer.parameters())\n",
    "\n",
    "\n",
    "    # Optimize iteration\n",
    "    # We divide the training set into \"Ntrain/BATCH\" groups\n",
    "    # For each group the final circuit will be used as the initial circuit for the next group\n",
    "    # Use cir to record the final circuit after learning.\n",
    "    i = 0  # Record the iteration number\n",
    "    for ep in range(EPOCH):\n",
    "        # Learn for each group\n",
    "        for itr in range(N_train // BATCH):\n",
    "            i += 1  # Record the iteration number\n",
    "            # Encode classical data into a quantum state |psi>, dimension [BATCH, 2 ** N]\n",
    "            input_state = paddle.to_tensor(datapoints_transform_to_state(train_x[itr * BATCH:(itr + 1) * BATCH], N))\n",
    "\n",
    "            # Run forward propagation to calculate loss function\n",
    "            loss, train_acc, state_predict_useless, cir \\\n",
    "                = myLayer(state_in=input_state, label=train_y[itr * BATCH:(itr + 1) * BATCH])  # optimize the given PQC\n",
    "            # Print the performance in iteration\n",
    "            if i % 30 == 5:\n",
    "                # Calculate the correct rate on the test set test_acc\n",
    "                input_state_test = paddle.to_tensor(datapoints_transform_to_state(test_x, N))\n",
    "                loss_useless, test_acc, state_predict_useless, t_cir \\\n",
    "                    = myLayer(state_in=input_state_test,label=test_y)\n",
    "                print(\"epoch:\", ep, \"iter:\", itr,\n",
    "                      \"loss: %.4f\" % loss.numpy(),\n",
    "                      \"train acc: %.4f\" % train_acc,\n",
    "                      \"test acc: %.4f\" % test_acc)\n",
    "                # Store accuracy rate and other information\n",
    "                summary_iter.append(itr + ep * N_train)\n",
    "                summary_test_acc.append(test_acc) \n",
    "\n",
    "            # Run back propagation to minimize the loss function\n",
    "            loss.backward()\n",
    "            opt.minimize(loss)\n",
    "            opt.clear_grad()\n",
    "            \n",
    "    # Print the final circuit\n",
    "    print(\"The trained circuit:\")\n",
    "    print(cir)\n",
    "    # Draw the decision boundary represented by heatmap\n",
    "    heatmap_plot(myLayer, N=N)\n",
    "\n",
    "    return summary_test_acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T04:04:19.852356Z",
     "start_time": "2021-03-09T04:03:38.709491Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The dimensions of the training set x (200, 2) and y (200, 1)\n",
      "The dimensions of the test set x (100, 2) and y (100, 1) \n",
      "\n",
      "epoch: 0 iter: 4 loss: 0.1547 train acc: 0.8500 test acc: 0.6400\n",
      "epoch: 3 iter: 4 loss: 0.1337 train acc: 0.9500 test acc: 0.8800\n",
      "epoch: 6 iter: 4 loss: 0.1265 train acc: 1.0000 test acc: 1.0000\n",
      "epoch: 9 iter: 4 loss: 0.1247 train acc: 1.0000 test acc: 1.0000\n",
      "epoch: 12 iter: 4 loss: 0.1261 train acc: 1.0000 test acc: 1.0000\n",
      "epoch: 15 iter: 4 loss: 0.1268 train acc: 1.0000 test acc: 1.0000\n",
      "epoch: 18 iter: 4 loss: 0.1269 train acc: 1.0000 test acc: 1.0000\n",
      "The trained circuit:\n",
      "--Rz(0.542)----Ry(3.458)----Rz(2.692)----*--------------x----Ry(6.191)--\n",
      "                                         |              |               \n",
      "--Rz(3.514)----Ry(1.543)----Rz(2.499)----x----*---------|----Ry(2.968)--\n",
      "                                              |         |               \n",
      "--Rz(5.947)----Ry(3.161)----Rz(3.897)---------x----*----|----Ry(1.579)--\n",
      "                                                   |    |               \n",
      "--Rz(0.718)----Ry(5.038)----Rz(1.348)--------------x----*----Ry(0.036)--\n",
      "                                                                        \n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The main program finished running in  8.05081820487976 seconds.\n"
     ]
    }
   ],
   "source": [
    "def main():\n",
    "    \"\"\"\n",
    "    main\n",
    "    \"\"\"\n",
    "    time_start = time.time()\n",
    "    acc = QClassifier(\n",
    "        Ntrain = 200,    # Specify the training set size\n",
    "        Ntest = 100,     # Specify the test set size\n",
    "        gap = 0.5,       # Set the width of the decision boundary\n",
    "        N = 4,           # Number of qubits required\n",
    "        DEPTH = 1,       # Circuit depth\n",
    "        BATCH = 20,      # Batch size during training\n",
    "        EPOCH = int(200 * BATCH / Ntrain),\n",
    "                        # Number of training epochs, the total iteration number \"EPOCH * (Ntrain / BATCH)\" is chosen to be about 200\n",
    "        LR = 0.01,       # Set the learning rate\n",
    "        seed_paras = 19, # Set random seed to initialize various parameters\n",
    "        seed_data = 2,   # Fixed random seed required to generate the data set\n",
    "    )\n",
    "    \n",
    "    time_span = time.time()-time_start\n",
    "    print('The main program finished running in ', time_span, 'seconds.')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By printing out the training results, you can see that the classification accuracy in the test set and the data set after continuous optimization has reached $100\\%$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Benchmarking Different Encoding Methods\n",
    "\n",
    "Encoding methods are fundemental in supervised quantum machine learning [4]. In paddle quantum, commonly used encoding methods such as amplitude encoding, angle encoding, IQP encoding, etc., are integrated. Simple classification data of users (without reducing dimensions) can be encoded by an instance of the ``SimpleDataset`` class and image data can be encoded by an instance of the ``VisionDataset`` class both using the method ``encode``."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "(100, 4)\n"
     ]
    }
   ],
   "source": [
    "# Use circle data above to accomplish classification\n",
    "from paddle_quantum.dataset import *\n",
    "\n",
    "# The data are two-dimensional and are encoded by two qubits\n",
    "quantum_train_x = SimpleDataset(2).encode(train_x, 'angle_encoding', 2)\n",
    "quantum_test_x = SimpleDataset(2).encode(test_x, 'angle_encoding', 2)\n",
    "\n",
    "print(type(quantum_test_x)) # ndarray\n",
    "print(quantum_test_x.shape) # (100, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we define an ordinary classifier, and it will be used by different data afterwards."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A simpler classifier\n",
    "def QClassifier2(quantum_train_x, train_y,quantum_test_x,test_y, N, DEPTH, EPOCH, LR, BATCH):\n",
    "    \"\"\"\n",
    "    Quantum Binary Classifier\n",
    "    Input：\n",
    "        quantum_train_x     # training x\n",
    "        train_y             # training y\n",
    "        quantum_test_x      # testing x\n",
    "        test_y              # testing y\n",
    "        N                   # Number of qubits required\n",
    "        DEPTH               # Circuit depth\n",
    "        EPOCH               # Number of training epochs\n",
    "        LR                  # Set the learning rate\n",
    "        BATCH               # Batch size during training\n",
    "    \"\"\"\n",
    "    Ntrain = len(quantum_train_x)\n",
    "    \n",
    "    paddle.seed(1)\n",
    "\n",
    "    net = Opt_Classifier(n=N, depth=DEPTH)\n",
    "\n",
    "    # Test accuracy list\n",
    "    summary_iter, summary_test_acc = [], []\n",
    "\n",
    "    # Adam can also be replaced by SGD or RMSprop\n",
    "    opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n",
    "\n",
    "    # Optimize\n",
    "    for ep in range(EPOCH):\n",
    "        for itr in range(Ntrain // BATCH):\n",
    "            # Import data\n",
    "            input_state = quantum_train_x[itr * BATCH:(itr + 1) * BATCH]  # paddle.tensor\n",
    "            input_state = reshape(input_state, [-1, 1, 2 ** N])\n",
    "            label = train_y[itr * BATCH:(itr + 1) * BATCH]\n",
    "            test_input_state = reshape(quantum_test_x, [-1, 1, 2 ** N])\n",
    "\n",
    "            loss, train_acc, state_predict_useless, cir = net(state_in=input_state, label=label)\n",
    "\n",
    "            if itr % 5 == 0:\n",
    "                # get accuracy on test dataset (test_acc)\n",
    "                loss_useless, test_acc, state_predict_useless, t_cir = net(state_in=test_input_state, label=test_y)\n",
    "                print(\"epoch:\", ep, \"iter:\", itr,\n",
    "                      \"loss: %.4f\" % loss.numpy(),\n",
    "                      \"train acc: %.4f\" % train_acc,\n",
    "                      \"test acc: %.4f\" % test_acc)\n",
    "                summary_test_acc.append(test_acc)\n",
    "\n",
    "            loss.backward()\n",
    "            opt.minimize(loss)\n",
    "            opt.clear_grad()\n",
    "\n",
    "    return summary_test_acc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can test different encoding methods on the circle data generated above. Here we choose five encoding methods: amplitude encoding, angle encoding, pauli rotation encoding, IQP encoding, and complex entangled encoding. Then the curves of the testing accuracy are shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Encoding method: amplitude_encoding\n",
      "epoch: 0 iter: 0 loss: 0.3066 train acc: 0.4000 test acc: 0.5400\n",
      "epoch: 0 iter: 5 loss: 0.2378 train acc: 0.7000 test acc: 0.7000\n",
      "epoch: 0 iter: 10 loss: 0.2308 train acc: 0.8000 test acc: 0.6700\n",
      "epoch: 0 iter: 15 loss: 0.2230 train acc: 0.8000 test acc: 0.6100\n",
      "Encoding method: angle_encoding\n",
      "epoch: 0 iter: 0 loss: 0.2949 train acc: 0.5000 test acc: 0.3600\n",
      "epoch: 0 iter: 5 loss: 0.1770 train acc: 0.7000 test acc: 0.7000\n",
      "epoch: 0 iter: 10 loss: 0.1654 train acc: 0.8000 test acc: 0.7000\n",
      "epoch: 0 iter: 15 loss: 0.1966 train acc: 0.7000 test acc: 0.5800\n",
      "Encoding method: pauli_rotation_encoding\n",
      "epoch: 0 iter: 0 loss: 0.2433 train acc: 0.6000 test acc: 0.7000\n",
      "epoch: 0 iter: 5 loss: 0.2142 train acc: 0.7000 test acc: 0.7000\n",
      "epoch: 0 iter: 10 loss: 0.2148 train acc: 0.7000 test acc: 0.7000\n",
      "epoch: 0 iter: 15 loss: 0.2019 train acc: 0.8000 test acc: 0.7600\n",
      "Encoding method: IQP_encoding\n",
      "epoch: 0 iter: 0 loss: 0.2760 train acc: 0.6000 test acc: 0.4200\n",
      "epoch: 0 iter: 5 loss: 0.1916 train acc: 0.6000 test acc: 0.6200\n",
      "epoch: 0 iter: 10 loss: 0.1355 train acc: 0.9000 test acc: 0.7300\n",
      "epoch: 0 iter: 15 loss: 0.1289 train acc: 0.9000 test acc: 0.6700\n",
      "Encoding method: complex_entangled_encoding\n",
      "epoch: 0 iter: 0 loss: 0.3274 train acc: 0.3000 test acc: 0.2900\n",
      "epoch: 0 iter: 5 loss: 0.2120 train acc: 0.7000 test acc: 0.7000\n",
      "epoch: 0 iter: 10 loss: 0.2237 train acc: 0.7000 test acc: 0.7000\n",
      "epoch: 0 iter: 15 loss: 0.2095 train acc: 0.8000 test acc: 0.7200\n"
     ]
    }
   ],
   "source": [
    "# Testing different encoding methods\n",
    "encoding_list = ['amplitude_encoding', 'angle_encoding', 'pauli_rotation_encoding', 'IQP_encoding', 'complex_entangled_encoding']\n",
    "num_qubit = 2 # If qubit number is 1, CNOT gate in cir_classifier can not be used\n",
    "dimension = 2\n",
    "acc_list = []\n",
    "\n",
    "for i in range(len(encoding_list)):\n",
    "    encoding = encoding_list[i]\n",
    "    print(\"Encoding method:\", encoding)\n",
    "    # Use SimpleDataset to encode the data\n",
    "    quantum_train_x= SimpleDataset(dimension).encode(train_x, encoding, num_qubit)\n",
    "    quantum_test_x= SimpleDataset(dimension).encode(test_x, encoding, num_qubit)\n",
    "    quantum_train_x = paddle.to_tensor(quantum_train_x)\n",
    "    quantum_test_x = paddle.to_tensor(quantum_test_x)\n",
    "    \n",
    "    acc = QClassifier2(\n",
    "            quantum_train_x, # Training x\n",
    "            train_y,         # Training y\n",
    "            quantum_test_x,  # Testing x\n",
    "            test_y,          # Testing y\n",
    "            N = num_qubit,   # Number of qubits required\n",
    "            DEPTH = 1,       # Circuit depth\n",
    "            EPOCH = 1,       # Number of training epochs\n",
    "            LR = 0.1,        # Set the learning rate\n",
    "            BATCH = 10,      # Batch size during training\n",
    "          )\n",
    "    acc_list.append(acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Benchmarking different encoding methods\n",
    "x=[2*i for i in range(len(acc_list[0]))]\n",
    "for i in range(len(encoding_list)):\n",
    "    plt.plot(x,acc_list[i])\n",
    "plt.legend(encoding_list)\n",
    "plt.title(\"Benchmarking different encoding methods\")\n",
    "plt.xlabel(\"Iteration\")\n",
    "plt.ylabel(\"Test accuracy\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quantum Classification on Built-In MNIST and Iris Datasets\n",
    "\n",
    "Paddle Quantum provides datasets commonly used in quantum classification tasks, and users can use the `paddle_quantum.dataset` module to get the encoding circuits or encoded states. There are four built-in datasets in Paddle Quantum at present, including MNIST, FashionMNIST, Iris and BreastCancer. We can easily accomplishing quantum classification using these quantum datasets.\n",
    "\n",
    "The first case is Iris. It has three types of labels and 50 samples of each type. There are only four features in Iris data, and it is very easy to fulfill its classification."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\yeruilin\\Anaconda3\\envs\\paddle_quantum_env\\lib\\site-packages\\paddle\\fluid\\dygraph\\math_op_patch.py:237: UserWarning: The dtype of left and right variables are not the same, left dtype is paddle.float64, but right dtype is paddle.int32, the right dtype will convert to paddle.float64\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 0 iter: 0 loss: 0.3113 train acc: 0.0000 test acc: 0.0000\n",
      "epoch: 0 iter: 5 loss: 0.4818 train acc: 0.0000 test acc: 0.3500\n",
      "epoch: 0 iter: 10 loss: 0.2171 train acc: 1.0000 test acc: 1.0000\n",
      "epoch: 0 iter: 15 loss: 0.1688 train acc: 1.0000 test acc: 1.0000\n",
      "epoch: 1 iter: 0 loss: 0.1350 train acc: 1.0000 test acc: 1.0000\n",
      "epoch: 1 iter: 5 loss: 0.1110 train acc: 1.0000 test acc: 1.0000\n",
      "epoch: 1 iter: 10 loss: 0.0879 train acc: 1.0000 test acc: 1.0000\n",
      "epoch: 1 iter: 15 loss: 0.0490 train acc: 1.0000 test acc: 1.0000\n",
      "epoch: 2 iter: 0 loss: 0.0733 train acc: 1.0000 test acc: 1.0000\n",
      "epoch: 2 iter: 5 loss: 0.0740 train acc: 1.0000 test acc: 1.0000\n",
      "epoch: 2 iter: 10 loss: 0.0660 train acc: 1.0000 test acc: 1.0000\n",
      "epoch: 2 iter: 15 loss: 0.0394 train acc: 1.0000 test acc: 1.0000\n",
      "epoch: 3 iter: 0 loss: 0.0654 train acc: 1.0000 test acc: 1.0000\n",
      "epoch: 3 iter: 5 loss: 0.0557 train acc: 1.0000 test acc: 1.0000\n",
      "epoch: 3 iter: 10 loss: 0.0602 train acc: 1.0000 test acc: 1.0000\n",
      "epoch: 3 iter: 15 loss: 0.0397 train acc: 1.0000 test acc: 1.0000\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Using Iris\n",
    "test_rate = 0.2\n",
    "num_qubit = 4\n",
    "\n",
    "# acquire Iris data as quantum states\n",
    "iris =Iris (encoding='angle_encoding', num_qubits=num_qubit, test_rate=test_rate,classes=[0, 1], return_state=True)\n",
    "\n",
    "quantum_train_x, train_y = iris.train_x, iris.train_y\n",
    "quantum_test_x, test_y = iris.test_x, iris.test_y\n",
    "testing_data_num = len(test_y)\n",
    "training_data_num = len(train_y)\n",
    "\n",
    "acc = QClassifier2(\n",
    "        quantum_train_x, # training x\n",
    "        train_y,         # training y\n",
    "        quantum_test_x,  # testing x\n",
    "        test_y,          # testing y\n",
    "        N = num_qubit,   # Number of qubits required\n",
    "        DEPTH = 1,       # Circuit depth\n",
    "        EPOCH = 4,       # Number of training epochs, the total iteration number \"EPOCH * (Ntrain / BATCH)\" is chosen to be about 200\n",
    "        LR = 0.1,        # Set the learning rate\n",
    "        BATCH = 4,       # Batch size during training\n",
    "      )\n",
    "plt.plot(acc)\n",
    "plt.title(\"Classify Iris 0&1 using angle encoding\")\n",
    "plt.xlabel(\"Iteration\")\n",
    "plt.ylabel(\"Testing accuracy\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The second case is MNIST. It is a handwritten digit dataset and has 10 classes. Each figure has $28\\times28$ pixels, and downscaling methods such as ``resize`` and ``PCA`` should be used to transform it into the target dimension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 0 iter: 0 loss: 0.3237 train acc: 0.3250 test acc: 0.5450\n",
      "epoch: 0 iter: 5 loss: 0.2124 train acc: 0.7500 test acc: 0.6500\n",
      "epoch: 0 iter: 10 loss: 0.2294 train acc: 0.6500 test acc: 0.6850\n",
      "epoch: 1 iter: 0 loss: 0.1970 train acc: 0.7250 test acc: 0.7850\n",
      "epoch: 1 iter: 5 loss: 0.1521 train acc: 0.8500 test acc: 0.8150\n",
      "epoch: 1 iter: 10 loss: 0.1726 train acc: 0.7750 test acc: 0.8900\n",
      "epoch: 2 iter: 0 loss: 0.1742 train acc: 0.7250 test acc: 0.8650\n",
      "epoch: 2 iter: 5 loss: 0.1167 train acc: 0.9000 test acc: 0.8900\n",
      "epoch: 2 iter: 10 loss: 0.1654 train acc: 0.8000 test acc: 0.8950\n",
      "epoch: 3 iter: 0 loss: 0.1609 train acc: 0.8000 test acc: 0.8850\n",
      "epoch: 3 iter: 5 loss: 0.1148 train acc: 0.9250 test acc: 0.8850\n",
      "epoch: 3 iter: 10 loss: 0.1649 train acc: 0.8000 test acc: 0.8750\n",
      "epoch: 4 iter: 0 loss: 0.1629 train acc: 0.8250 test acc: 0.8750\n",
      "epoch: 4 iter: 5 loss: 0.1112 train acc: 0.9000 test acc: 0.8700\n",
      "epoch: 4 iter: 10 loss: 0.1630 train acc: 0.8500 test acc: 0.8850\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# using MNIST\n",
    "\n",
    "# main parameters\n",
    "training_data_num = 500\n",
    "testing_data_num = 200\n",
    "qubit_num = 4\n",
    "\n",
    "# MNIST data with amplitude encoding, resized to 4*4\n",
    "train_dataset = MNIST(mode='train', encoding='amplitude_encoding', num_qubits=qubit_num, classes=[3, 6],\n",
    "                      data_num=training_data_num, need_cropping=True,\n",
    "                      downscaling_method='resize', target_dimension=16, return_state=True)\n",
    "\n",
    "val_dataset = MNIST(mode='test', encoding='amplitude_encoding', num_qubits=qubit_num, classes=[3, 6],\n",
    "                    data_num=testing_data_num, need_cropping=True,\n",
    "                    downscaling_method='resize', target_dimension=16,return_state=True)\n",
    "\n",
    "quantum_train_x, train_y = train_dataset.quantum_image_states, train_dataset.labels\n",
    "quantum_test_x, test_y = val_dataset.quantum_image_states, val_dataset.labels\n",
    "\n",
    "acc = QClassifier2(\n",
    "        quantum_train_x, # Training x\n",
    "        train_y,         # Training y\n",
    "        quantum_test_x,  # Testing x\n",
    "        test_y,          # Testing y\n",
    "        N = qubit_num,   # Number of qubits required\n",
    "        DEPTH = 3,       # Circuit depth\n",
    "        EPOCH = 5,       # Number of training epochs, the total iteration number \"EPOCH * (Ntrain / BATCH)\" is chosen to be about 200\n",
    "        LR = 0.1,        # Set the learning rate\n",
    "        BATCH = 40,      # Batch size during training\n",
    "      )\n",
    "\n",
    "plt.plot(acc)\n",
    "plt.title(\"Classify MNIST 3&6 using amplitude encoding\")\n",
    "plt.xlabel(\"Iteration\")\n",
    "plt.ylabel(\"Testing accuracy\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_______\n",
    "\n",
    "## References\n",
    "\n",
    "\n",
    "[1] Mitarai, Kosuke, et al. Quantum circuit learning. [Physical Review A 98.3 (2018): 032309.](https://arxiv.org/abs/1803.00745)\n",
    "\n",
    "[2] Farhi, Edward, and Hartmut Neven. Classification with quantum neural networks on near term processors. [arXiv preprint arXiv:1802.06002 (2018).](https://arxiv.org/abs/1802.06002)\n",
    "\n",
    "[3] Schuld, Maria, et al. Circuit-centric quantum classifiers. [Physical Review A 101.3 (2020): 032308.](https://arxiv.org/abs/1804.00633)\n",
    "\n",
    "[4] Schuld, Maria. Supervised quantum machine learning models are kernel methods. [arXiv preprint arXiv:2101.11020 (2021).](https://arxiv.org/pdf/2101.11020)"
   ]
  }
 ],
 "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.12"
  },
  "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
}