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. Finally, we benchmark the optimal classification performance through test data.\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": [],
   "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  # 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": [
    "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"
   ]
  },
  {
   "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:]\n"
   ]
  },
  {
   "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": [
    "# Set parameters\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\n",
    "\n",
    "# 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",
    "\n",
    "    res = np.array(res)\n",
    "    return res.astype(\"complex128\")\n"
   ]
  },
  {
   "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": 8,
   "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\n"
   ]
  },
  {
   "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",
    "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": 9,
   "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",
    "    return Ob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "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",
    "        \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 = paddle.to_tensor(label)\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 expected 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\n",
    "    "
   ]
  },
  {
   "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",
    "    \"\"\"\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\n"
   ]
  },
  {
   "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  7.169757127761841 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",
    "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": [
    "_______\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"
   ]
  }
 ],
 "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.7.11"
  },
  "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
}