{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Encoding Analysis\n",
    "\n",
    "*Copyright (c) 2022 Institute for Quantum Computing, Baidu Inc. All Rights Reserved.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Overview\n",
    "\n",
    "Many studies are now exhibiting the promise of Variational Quantum Algorithms (VQA) in demonstrating quantum advantages on near-term quantum devices, with particular emphasis on using them to solve supervised learning tasks. VQA is also known as a Parameterized Quantum Circuit (PQC), which is divided into two main parts in this tutorial: the data encoding circuit and the quantum neural network. The data encoding circuit converts classical data into quantum states, and the quality of the quantum states has a direct impact on the classification results. When data encoding is analyzed through the perspective of kernel functions, different encoding methods correspond to different kernel functions, which play a critical role in the classification of quantum states [1,2]. It often determines the expressiveness and generalization ability of the method by analyzing data encoding from the standpoint of statistical learning theory [3,4]. Therefore, it is necessary to conduct a systematic analysis of data encoding. From the standpoint of quantum information, literature [5] critically analyzes the effect of the width and depth of the data encoding circuit on the quantum state.\n",
    "\n",
    "The next part of the tutorial is organized around the literature [5] and is divided into two parts: theory and Paddle Quantum implementation. The fundamental concepts and main conclusions are introduced first, followed by specific implementation solutions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Theory"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fundamental Concepts\n",
    "\n",
    "Figure 1 shows the flowchart for encoding classical data into quantum states. Assume that the classical data are independent identically distributed samples of distribution $D$, each classical data is $\\pmb x$, which becomes a quantum state $\\rho(\\pmb x)$ after passing through the data encoding circuit. Here the concept of **average quantum state** over the distribution $D$ is introduced, i.e. \n",
    "\n",
    "$$\n",
    "\\bar{\\rho}:=\\mathbf{E}[\\rho(\\pmb x)]. \\tag{1}\n",
    "$$\n",
    "\n",
    "Given a classical data set $S$ consisting of $M$ data, we usually use the average value to approximate the average quantum state of $S$\n",
    "\n",
    "$$\n",
    "\\bar{\\rho}:=\\frac{1}{M}\\sum_{j=1}^M\\rho(\\pmb x_j). \\tag{2}\n",
    "$$\n",
    "\n",
    "\n",
    "![illustration](figures/EncodingAnalysis-fig-illustration.png  \"Figure 1: Flowchart for encoding classical data into quantum states.\")\n",
    "\n",
    "There are various methods for measuring the distance between quantum states, including trace distance, fidelity, **Petz-Rényi divergence**, and others. In this tutorial, the Petz-Rényi divergence is used as a measure of the distance between different quantum states. Specifically, the Petz-Rényi divergence of the quantum states $\\rho_0$ and $\\rho_1$ is defined as\n",
    "\n",
    "$$\n",
    "D_2(\\rho_0||\\rho_1)=logTr[\\rho_0^2\\rho_1^{-1}], \\tag{3}\n",
    "$$\n",
    "\n",
    "the closer the two quantum states are, the smaller the value of $D_2$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Main Result\n",
    "\n",
    "The Petz-Rényi divergence metric is then used to calculate the distance between the encoding average quantum state and the maximum mixed state. It is not difficult to believe that this distance is related to the property of the classical dataset and how the data are encoded. Assume that each feature dimension of the classical dataset satisfies certain independence and has a standard deviation of at least $\\sigma$. The following inequality then holds for the encoding circuit depicted in figure 2 (with width and depth $n$ and $D$, respectively)\n",
    "\n",
    "$$\n",
    "D_2(\\bar{\\rho}||I/2^n)\\leq log(1+(2^n-1)2^{-D\\sigma^2}), \\tag{4}\n",
    "$$\n",
    "\n",
    "where $I/2^n$ is the maximum mixed state of $n$ bits and $I$ is the unit matrix.\n",
    "\n",
    "![encoding-u3](figures/EncodingAnalysis-fig-u3_circuit.png \" Figure 2: General data encoding circuits. Etg denotes any combination of control non-gates and CZ gates.\")\n",
    "\n",
    "A more rigorous description and proof of the theorem can be found in [5], and the focus of this tutorial will be on what this conclusion implies and illuminates.\n",
    "\n",
    "* This means that the average quantum state converges to the maximum mixed state at an exponential rate as the circuit depth increases. For example, if the average quantum states of both classes 0 and 1 eventually converge to the maximum mixed state, it will be impossible to distinguish the average quantum states of these two classes from the standpoint of quantum information, i.e., it will be impossible to distinguish classical data features in an average sense.\n",
    "\n",
    "* When the classical data features have a high dimensionality (e.g., picture data), angle encoding may not be the best option. This is due to the fact that it can easily lead to very deep encoding circuits, and widening circuits may run into the barren plateau problem, which severely limits VQA's capability. As a result, some dimensionality reduction operations must be performed on the traditional data before it is fed into the circuit."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Paddle Quantum Implementation\n",
    "\n",
    "This section focuses on two experiments using Paddle Quantum on the MNIST dataset: \n",
    "- Exploring the trend of the Petz-Rényi divergence between the average quantum state and the maximum mixed state with the depth of the data encoding circuit\n",
    "- Investigate changes in classification accuracy as the data encoding circuit becomes deeper."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### First import the relevant packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import numpy, paddle, and paddle_quantum\n",
    "import numpy as np\n",
    "import paddle\n",
    "import paddle_quantum\n",
    "\n",
    "# import circuit module\n",
    "from paddle_quantum.ansatz import Circuit\n",
    "\n",
    "# import some function\n",
    "from numpy import pi as PI\n",
    "from paddle import matmul, transpose, reshape, real, argmax, cast, mean, concat, real\n",
    "from paddle_quantum.qinfo import pauli_str_to_matrix \n",
    "from paddle_quantum.linalg import dagger\n",
    "import paddle.nn.functional as F\n",
    "\n",
    "# dataset tool\n",
    "from paddle_quantum.dataset import MNIST\n",
    "\n",
    "# plot and time module\n",
    "from matplotlib import pyplot as plt\n",
    "from pylab import axes\n",
    "import time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parameterized Quantum Circuit\n",
    "\n",
    "![encoding-ry](figures/EncodingAnalysis-fig-ry_circuit.png \"Figure 3: Parameterized quantum circuit.\")\n",
    "\n",
    "The red box on the left in Figure 3 is the data encoding circuit, a special case of Figure 2, and the blue box on the right is the quantum neural network. The data encoding circuit here is made up of $R_y$ and CNOT, and the specific circuit depth $D$ is determined by the data feature dimension. The MNIST dataset will be used in this tutorial and the images are downscaled to 16-dimensional feature vectors. The number of quantum bits is chosen to be 8, 6, 4, 3, 2, and the corresponding circuit depths are 2, 3, 4, 6, 8. The positions larger than 16 dimensions will be filled with 0, i.e., $R_y(0)$. The quantum neural network part consists of the single-bit universal gate $U3$ and CNOT.\n",
    "The specific circuit depth $L$ can be set freely."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Encoding classical Data into quantum states\n",
    "\n",
    "Here you need the dataset tool `dataset` provided by Paddle Quantum. The MNIST data are encoded into quantum states using the data encoding circuit shown in Figure 2 before being fed into the quantum neural network for training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data, test_data = [], []\n",
    "\n",
    "# Binary classification task \n",
    "classes = [3,6]\n",
    "\n",
    "training_data_num = 1000\n",
    "testing_data_num = 200\n",
    "qubit_num_list = [8, 6, 4, 3, 2]\n",
    "\n",
    "# Encode classical data using circuits of different widths and depths and save them\n",
    "for qubit_num in qubit_num_list:\n",
    "    \n",
    "    # training dataset\n",
    "    train_dataset = MNIST(mode='train', encoding='real_entangled_encoding', num_qubits=qubit_num,\n",
    "                          classes=classes,\n",
    "                          data_num=training_data_num,\n",
    "                          downscaling_method='resize', target_dimension=16,\n",
    "                          need_relabel=True, return_state=True)\n",
    "\n",
    "    # validation dataset\n",
    "    val_dataset = MNIST(mode='test', encoding='real_entangled_encoding', num_qubits=qubit_num,\n",
    "                        classes=classes,\n",
    "                        data_num=testing_data_num,\n",
    "                        downscaling_method='resize', target_dimension=16,\n",
    "                        need_relabel=True, return_state=True)\n",
    "\n",
    "    # x and y\n",
    "    train_x, train_y = train_dataset.quantum_image_states, train_dataset.labels\n",
    "    test_x, test_y = val_dataset.quantum_image_states, val_dataset.labels\n",
    "    train_data.append((train_x, train_y))\n",
    "    test_data.append((test_x, test_y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1000, 256]\n",
      "(1000,)\n",
      "[200, 256]\n",
      "(200,)\n"
     ]
    }
   ],
   "source": [
    "print(train_data[0][0].shape)\n",
    "print(train_data[0][1].shape)\n",
    "print(test_data[0][0].shape)\n",
    "print(test_data[0][1].shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building Quantum Neural Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Construct model\n",
    "class Net(paddle.nn.Layer):\n",
    "    \"\"\"\n",
    "    construct network\n",
    "    \"\"\"\n",
    "    def __init__(self, n, depth):\n",
    "        # Initialize the circuit: n, depth\n",
    "        super(Net, self).__init__()\n",
    "        self.n = n\n",
    "        self.depth = depth\n",
    "        \n",
    "        self.circuit = Circuit(n)\n",
    "        # Add layers of rotation gates\n",
    "        for i in range(n):\n",
    "            self.circuit.rz(qubits_idx=i)\n",
    "            self.circuit.ry(qubits_idx=i)\n",
    "            self.circuit.rz(qubits_idx=i)\n",
    "\n",
    "        # default depth = 1\n",
    "        # Add layers of entanglement\n",
    "        for d in range(3, depth + 3):\n",
    "            for i in range(n-1):\n",
    "                self.circuit.cnot(qubits_idx=[i, i + 1])\n",
    "            self.circuit.cnot(qubits_idx=[n-1, 0])\n",
    "            for i in range(n):\n",
    "                self.circuit.ry(qubits_idx=i)\n",
    "\n",
    "    # Define forward propagation mechanism, and then calculate loss function and cross-validation accuracy\n",
    "    def forward(self, state_in, label):\n",
    "        \"\"\"\n",
    "        Input: \n",
    "            state_in: input quantum state, shape: [-1, 1, 2^n] -- Here is [BATCH, 1, 2^n]\n",
    "            label: labels of input quantum state, shape: [-1, 1]\n",
    "        Loss function:\n",
    "            The cross entropy loss \n",
    "        \"\"\"\n",
    "        # Initialize theta \n",
    "        Utheta = self.circuit.unitary_matrix()\n",
    "\n",
    "        # row vector operations here to speed up \n",
    "        state_out = matmul(state_in, Utheta)  # shape [-1, 1, 2 ** n]\n",
    "\n",
    "        # Measure the expected value of the pauli Z operator <Z>\n",
    "        Ob1 = paddle.to_tensor(pauli_str_to_matrix([[1.0, 'z0']], self.n))\n",
    "        E_Ob1 = matmul(matmul(state_out, Ob1), transpose(paddle.conj(state_out), perm=[0, 2, 1]))\n",
    "        E_Ob1_re = reshape(real(E_Ob1), [-1, 1])\n",
    "\n",
    "        Ob2 = paddle.to_tensor(pauli_str_to_matrix([[1.0, 'x0']], self.n))\n",
    "        E_Ob2 = matmul(matmul(state_out, Ob2), transpose(paddle.conj(state_out), perm=[0, 2, 1]))\n",
    "        E_Ob2_re = reshape(real(E_Ob2), [-1, 1])\n",
    "\n",
    "        outputs = concat([E_Ob1_re, E_Ob2_re], axis=-1)\n",
    "    \n",
    "        # Calculate loss and accuracy\n",
    "        loss = F.cross_entropy(outputs, label)\n",
    "        acc = mean(cast(argmax(outputs, axis=-1) == label, \"float32\"))\n",
    "        \n",
    "        return loss, acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a classifier\n",
    "def QClassifier(train_x, train_y, test_x, test_y, N, D, EPOCH, LR, BATCH, seed=0):\n",
    "    \"\"\"\n",
    "    Quantum binary classifier\n",
    "    \"\"\"\n",
    "    train_y = paddle.to_tensor(train_y, dtype=\"int64\")\n",
    "    test_y = paddle.to_tensor(test_y, dtype=\"int64\")\n",
    "\n",
    "    N_train, in_dim = train_x.shape\n",
    "    \n",
    "    # Initialize the neural network\n",
    "    paddle.seed(0)\n",
    "    net = Net(n=N, depth=D)\n",
    "\n",
    "    # Generally speaking, we use Adam optimizer to obtain relatively good convergence,\n",
    "    # You can change it to SGD or RMS prop.\n",
    "    opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n",
    "\n",
    "    # Optimization loop\n",
    "    for ep in range(EPOCH):\n",
    "        for itr in range(N_train // BATCH):\n",
    "            input_state = train_x[itr * BATCH:(itr + 1) * BATCH]\n",
    "            input_state = reshape(input_state, [-1, 1, 2 ** N])\n",
    "            label = train_y[itr * BATCH:(itr + 1) * BATCH]\n",
    "\n",
    "            test_input_state = reshape(test_x, [-1, 1, 2 ** N])\n",
    "\n",
    "            # Forward propagation to calculate loss and accuracy\n",
    "            train_loss, train_acc = net(state_in=input_state, label=label)\n",
    "\n",
    "            if itr % 3 == 0:\n",
    "                # Compute test accuracy and loss\n",
    "                loss_useless, test_acc = net(state_in=test_input_state, label=test_y)\n",
    "                print(\"epoch:\", ep, \"iter:\", itr,\n",
    "                      \"train loss: %.4f\" % train_loss.numpy(),\n",
    "                      \"train acc: %.4f\" % train_acc,\n",
    "                      \"test acc: %.4f\" % test_acc)\n",
    "\n",
    "            # Use back propagation to minimize the loss function\n",
    "            train_loss.backward()\n",
    "            opt.minimize(train_loss)\n",
    "            opt.clear_grad()\n",
    "    \n",
    "    # Compute test accuracy and loss\n",
    "    _, test_acc = net(state_in=test_input_state, label=test_y) \n",
    "    \n",
    "    return test_acc.numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "***************************** qubit num : 8 *****************************\n",
      "epoch: 0 iter: 0 train loss: 0.6913 train acc: 0.5200 test acc: 0.4250\n",
      "epoch: 0 iter: 3 train loss: 0.6836 train acc: 0.6500 test acc: 0.5200\n",
      "epoch: 1 iter: 0 train loss: 0.6759 train acc: 0.6850 test acc: 0.5550\n",
      "epoch: 1 iter: 3 train loss: 0.6709 train acc: 0.6950 test acc: 0.5650\n",
      "epoch: 2 iter: 0 train loss: 0.6651 train acc: 0.6650 test acc: 0.5700\n",
      "epoch: 2 iter: 3 train loss: 0.6621 train acc: 0.7050 test acc: 0.6050\n",
      "epoch: 3 iter: 0 train loss: 0.6589 train acc: 0.6900 test acc: 0.6000\n",
      "epoch: 3 iter: 3 train loss: 0.6597 train acc: 0.7050 test acc: 0.6250\n",
      "epoch: 4 iter: 0 train loss: 0.6563 train acc: 0.7150 test acc: 0.6550\n",
      "epoch: 4 iter: 3 train loss: 0.6566 train acc: 0.7250 test acc: 0.6700\n",
      "***************************** qubit num : 6 *****************************\n",
      "epoch: 0 iter: 0 train loss: 0.6966 train acc: 0.4900 test acc: 0.5250\n",
      "epoch: 0 iter: 3 train loss: 0.6938 train acc: 0.4850 test acc: 0.5450\n",
      "epoch: 1 iter: 0 train loss: 0.6884 train acc: 0.5350 test acc: 0.5450\n",
      "epoch: 1 iter: 3 train loss: 0.6862 train acc: 0.5400 test acc: 0.5700\n",
      "epoch: 2 iter: 0 train loss: 0.6775 train acc: 0.5750 test acc: 0.5850\n",
      "epoch: 2 iter: 3 train loss: 0.6744 train acc: 0.6100 test acc: 0.6000\n",
      "epoch: 3 iter: 0 train loss: 0.6642 train acc: 0.6350 test acc: 0.5950\n",
      "epoch: 3 iter: 3 train loss: 0.6615 train acc: 0.6450 test acc: 0.6200\n",
      "epoch: 4 iter: 0 train loss: 0.6526 train acc: 0.6900 test acc: 0.6300\n",
      "epoch: 4 iter: 3 train loss: 0.6560 train acc: 0.6250 test acc: 0.6350\n",
      "***************************** qubit num : 4 *****************************\n",
      "epoch: 0 iter: 0 train loss: 0.7081 train acc: 0.4650 test acc: 0.5350\n",
      "epoch: 0 iter: 3 train loss: 0.6994 train acc: 0.4950 test acc: 0.5900\n",
      "epoch: 1 iter: 0 train loss: 0.6902 train acc: 0.5450 test acc: 0.5750\n",
      "epoch: 1 iter: 3 train loss: 0.6942 train acc: 0.5150 test acc: 0.5800\n",
      "epoch: 2 iter: 0 train loss: 0.6869 train acc: 0.6100 test acc: 0.5850\n",
      "epoch: 2 iter: 3 train loss: 0.6923 train acc: 0.5150 test acc: 0.6000\n",
      "epoch: 3 iter: 0 train loss: 0.6825 train acc: 0.5700 test acc: 0.6050\n",
      "epoch: 3 iter: 3 train loss: 0.6917 train acc: 0.5200 test acc: 0.5950\n",
      "epoch: 4 iter: 0 train loss: 0.6776 train acc: 0.5850 test acc: 0.5800\n",
      "epoch: 4 iter: 3 train loss: 0.6901 train acc: 0.5450 test acc: 0.6050\n",
      "***************************** qubit num : 3 *****************************\n",
      "epoch: 0 iter: 0 train loss: 0.7104 train acc: 0.4550 test acc: 0.5000\n",
      "epoch: 0 iter: 3 train loss: 0.6931 train acc: 0.4950 test acc: 0.4900\n",
      "epoch: 1 iter: 0 train loss: 0.6928 train acc: 0.4600 test acc: 0.4700\n",
      "epoch: 1 iter: 3 train loss: 0.6968 train acc: 0.4800 test acc: 0.4800\n",
      "epoch: 2 iter: 0 train loss: 0.6964 train acc: 0.5100 test acc: 0.4750\n",
      "epoch: 2 iter: 3 train loss: 0.7004 train acc: 0.5150 test acc: 0.4600\n",
      "epoch: 3 iter: 0 train loss: 0.6961 train acc: 0.5050 test acc: 0.4800\n",
      "epoch: 3 iter: 3 train loss: 0.6957 train acc: 0.5300 test acc: 0.4850\n",
      "epoch: 4 iter: 0 train loss: 0.6938 train acc: 0.5250 test acc: 0.5150\n",
      "epoch: 4 iter: 3 train loss: 0.6919 train acc: 0.5150 test acc: 0.5250\n",
      "***************************** qubit num : 2 *****************************\n",
      "epoch: 0 iter: 0 train loss: 0.7031 train acc: 0.5450 test acc: 0.4800\n",
      "epoch: 0 iter: 3 train loss: 0.6960 train acc: 0.5350 test acc: 0.4550\n",
      "epoch: 1 iter: 0 train loss: 0.6932 train acc: 0.5100 test acc: 0.5100\n",
      "epoch: 1 iter: 3 train loss: 0.6930 train acc: 0.5250 test acc: 0.5200\n",
      "epoch: 2 iter: 0 train loss: 0.6930 train acc: 0.5150 test acc: 0.4750\n",
      "epoch: 2 iter: 3 train loss: 0.6933 train acc: 0.5050 test acc: 0.4600\n",
      "epoch: 3 iter: 0 train loss: 0.6925 train acc: 0.5400 test acc: 0.4600\n",
      "epoch: 3 iter: 3 train loss: 0.6909 train acc: 0.5350 test acc: 0.4700\n",
      "epoch: 4 iter: 0 train loss: 0.6939 train acc: 0.5450 test acc: 0.4750\n",
      "epoch: 4 iter: 3 train loss: 0.6853 train acc: 0.5600 test acc: 0.4750\n",
      "time used: 184.6011986732483 s\n"
     ]
    }
   ],
   "source": [
    "time_start = time.time()\n",
    "\n",
    "acc_list = []\n",
    "\n",
    "for i in range(5):\n",
    "    print('***************************** qubit num : %s *****************************'%qubit_num_list[i])\n",
    "    train_x, train_y = train_data[i]\n",
    "    test_x, test_y = test_data[i]\n",
    "\n",
    "    acc = QClassifier(\n",
    "        train_x,                  # training data x\n",
    "        train_y,                  # training data label\n",
    "        test_x,                   # test data x\n",
    "        test_y,                   # test data label\n",
    "        N=qubit_num_list[i],      # Number of qubits\n",
    "        D=qubit_num_list[i] + 2,  # Circuit depth\n",
    "        EPOCH=5,                  # Number of training epochs\n",
    "        LR=0.05,                  # Learning rate\n",
    "        BATCH=200,                # Batch size\n",
    "        seed=0\n",
    "    )\n",
    "    acc_list.append(acc)      \n",
    "\n",
    "time_span = time.time() - time_start\n",
    "print('time used:', time_span, 's')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Petz-Rényi divergence of the average quantum state and the maximum mixed state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.9842463368536747, 0.5256437464833253, 0.1964853652901484, 0.05162865627740749, 0.022790754263846934]\n",
      "[1.8628793706046225, 0.6064395532199834, 0.1529884926031612, 0.04173701231534178, 0.009023512622560221]\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": [
    "fig = plt.figure(1)\n",
    "ax = axes([0.15, 0.15, 0.8, 0.8])\n",
    "\n",
    "\n",
    "def average_encode_state(train_x):\n",
    "    d1, d2 = train_x.shape\n",
    "    density_matrices = np.reshape(train_x, [d1, d2, 1]) @ np.reshape(np.conj(train_x), [d1, 1, d2])\n",
    "    return np.mean(density_matrices, axis=0)\n",
    "\n",
    "\n",
    "depth_list = [2, 3, 4, 6, 8]\n",
    "\n",
    "Q_2Renyi_D3_list = []\n",
    "Q_2Renyi_D6_list = []\n",
    "\n",
    "for i,q in enumerate(qubit_num_list):\n",
    "    train_x, train_y = train_data[i]\n",
    "    train_x = train_x.numpy()\n",
    "    \n",
    "    train_x0 = train_x[train_y == 0]\n",
    "    train_x1 = train_x[train_y == 1]\n",
    "    average_state0 = average_encode_state(train_x0.real)\n",
    "    average_state1 = average_encode_state(train_x1.real)\n",
    "#     print(average_state)\n",
    "    Q_2Renyi_D3 = np.log2(np.trace(average_state0 @ average_state0) * 2 ** q)\n",
    "    Q_2Renyi_D6 = np.log2(np.trace(average_state1 @ average_state1) * 2 ** q)\n",
    "#     bound = np.sum(np.sqrt(S0)) ** 2 / 2 ** num_qubits\n",
    "    Q_2Renyi_D3_list.append(Q_2Renyi_D3)\n",
    "    Q_2Renyi_D6_list.append(Q_2Renyi_D6)\n",
    "\n",
    "print(Q_2Renyi_D3_list)\n",
    "print(Q_2Renyi_D6_list)\n",
    "\n",
    "\n",
    "func3, = ax.plot(depth_list, Q_2Renyi_D3_list, linewidth=1.5,\n",
    "                 marker=\"<\",\n",
    "                 linestyle=\":\",\n",
    "                 color=\"r\"\n",
    "                 )\n",
    "\n",
    "func6, = ax.plot(depth_list, Q_2Renyi_D6_list, linewidth=1.5,\n",
    "                 marker=\"o\",\n",
    "                 linestyle=\"-.\",\n",
    "                 color=\"g\"\n",
    "                 )\n",
    "\n",
    "plt.xticks(fontsize=22)\n",
    "plt.yticks(fontsize=22)\n",
    "\n",
    "plt.xlabel(\"Depth\", fontsize=22)\n",
    "plt.ylabel(r\"$D_2(\\overline{\\rho} || I/2^n)$\", fontsize=22)\n",
    "ax.semilogy()\n",
    "ax.legend(handles=[func3, func6],\n",
    "          labels=[\"Digit 3\", \"Digit 6\"],\n",
    "          loc=\"best\",\n",
    "          fontsize=18)\n",
    "ax.grid(axis=\"y\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Investigating the effect on classification accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([0.675], dtype=float32), array([0.61], dtype=float32), array([0.585], dtype=float32), array([0.535], dtype=float32), array([0.475], dtype=float32)]\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": [
    "print(acc_list)\n",
    "\n",
    "fig = plt.figure(1)\n",
    "ax = axes([0.15, 0.15, 0.8, 0.8])\n",
    "\n",
    "func36_acc, = ax.plot(depth_list, acc_list, linewidth=1.5,\n",
    "                      marker=\"*\",\n",
    "                      linestyle=\"--\",\n",
    "                      color=\"b\"\n",
    "                      )\n",
    "\n",
    "plt.xticks(fontsize=22)\n",
    "plt.yticks(fontsize=22)\n",
    "plt.ylim(0.48, 0.75)\n",
    "plt.xlabel(\"Depth\", fontsize=22)\n",
    "plt.ylabel(r\"Test Accuracy\", fontsize=22)\n",
    "ax.legend(handles=[func36_acc,],\n",
    "          labels=[\"classifying 3 and 6\"],\n",
    "          loc=\"best\", fontsize=22)\n",
    "ax.grid(axis=\"y\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion\n",
    "\n",
    "According to the experimental results, the average quantum state of each category tends to the maximum mixed state at an exponential rate as the data encoding circuit deepens. As a result, the final quantum neural network's classification accuracy decreases. With the help of the literature [5], we have come to understand some of the limitations of angle coding. It is also acknowledged that designing a data coding strategy capable of solving real-world problems (often with high dimensionality of data features) is both urgent and difficult."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## References\n",
    "\n",
    "[1] Schuld, M. \"Quantum machine learning models are kernel methods.\" [arXiv preprint arXiv:2101.11020.(2021)](https://arxiv.org/abs/2101.11020)\n",
    "\n",
    "[2] Lloyd, Seth, et al. \"Quantum embeddings for machine learning.\" [arXiv preprint arXiv:2001.03622 (2020).](https://arxiv.org/pdf/2001.03622.pdf)\n",
    "\n",
    "[3] Caro, Matthias C., et al. \"Encoding-dependent generalization bounds for parametrized quantum circuits.\" [Quantum 5 (2021): 582.](https://quantum-journal.org/papers/q-2021-11-17-582/)\n",
    "\n",
    "[4] Leonardo Banchi, et al. \"Generalization in quantum machine learning: A quantum information standpoint.\" [PRX Quantum 2.4 (2021): 040321.](https://journals.aps.org/prxquantum/abstract/10.1103/PRXQuantum.2.040321)\n",
    "\n",
    "[5] Li, Guangxi, et al. \"Concentration of Data Encoding in Parameterized Quantum Circuits.\" [arXiv preprint arXiv:2206.08273 (2022).](https://arxiv.org/pdf/2206.08273.pdf)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.13 ('new_pq')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.13"
  },
  "vscode": {
   "interpreter": {
    "hash": "58b83104798ee1b81625bc6249d4d66f2bacd4a7d411a9b7a27bac0b4765adf2"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}