Feature_Selection_with_Qiskit.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6a4b1727",
   "metadata": {},
   "source": [
    "# Feature selection and then classification with [Qiskit](https://qiskit.org/documentation/stable/0.19/index.html)\n",
    "\n",
    "This notebook has two parts\n",
    "- __Feature selection__ can be cast as a Quadratic Unconstrained Binary Optimization (__QUBO__) problem [[arXiv:2104.04049](https://arxiv.org/abs/2104.04049), [arXiv:2203.13261](https://arxiv.org/abs/2203.13261)] that can be solved with [Qiskit Optimization](https://qiskit.org/ecosystem/optimization/). \n",
    "- __Classification__ is a Machine learning (__ML__) problem that can be completed with [Qiskit Machine Learning](https://qiskit.org/ecosystem/machine-learning/)\n",
    "\n",
    "\n",
    "\n",
    "Here, we have taken [sklearn.datasets](https://scikit-learn.org/stable/datasets/toy_dataset.html)\n",
    "and given several methods for both feature selection and classification."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "fa24894a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import time, copy, warnings\n",
    "\n",
    "\n",
    "from sklearn import linear_model, svm\n",
    "from sklearn.ensemble import GradientBoostingClassifier, RandomForestClassifier\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "\n",
    "\n",
    "'''datasets:'''\n",
    "from sklearn.datasets import (load_iris, load_wine, load_breast_cancer)\n",
    "\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.model_selection import train_test_split\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef90e9fc",
   "metadata": {},
   "source": [
    "## Data loading ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "09439ab4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of examples =  178\n",
      "number of features =  13\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(array([[0.84210526, 0.1916996 , 0.57219251, 0.25773196, 0.61956522,\n",
       "         0.62758621, 0.57383966, 0.28301887, 0.59305994, 0.37201365,\n",
       "         0.45528455, 0.97069597, 0.56134094],\n",
       "        [0.57105263, 0.2055336 , 0.4171123 , 0.03092784, 0.32608696,\n",
       "         0.57586207, 0.51054852, 0.24528302, 0.27444795, 0.26450512,\n",
       "         0.46341463, 0.78021978, 0.55064194],\n",
       "        [0.56052632, 0.3201581 , 0.70053476, 0.41237113, 0.33695652,\n",
       "         0.62758621, 0.61181435, 0.32075472, 0.75709779, 0.37542662,\n",
       "         0.44715447, 0.6959707 , 0.64693295]]),\n",
       " array([0, 0, 0]))"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset = load_wine()                         # choose one of the above datasets\n",
    "X, y = dataset.data, dataset.target\n",
    "\n",
    "\n",
    "X = MinMaxScaler().fit_transform(X)           # this will put all the feature (X) values in the interval [0,1]\n",
    "\n",
    "\n",
    "num_examples, num_features = X.shape   \n",
    "print(\"number of examples = \", num_examples)\n",
    "print(\"number of features = \", num_features)\n",
    "\n",
    "\n",
    "X[:3,:], y[:3]                                # first 3 examples"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7ba474e",
   "metadata": {},
   "source": [
    "## train test split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "020d8366",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(124, 13) (54, 13)\n"
     ]
    }
   ],
   "source": [
    "X_train_, X_test_, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)\n",
    "\n",
    "print(X_train_.shape, X_test_.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "758eb777",
   "metadata": {},
   "source": [
    "$ $\n",
    "\n",
    "$ $\n",
    "\n",
    "# Feature Selection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ab6cdba8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "feature_names = ['alcohol', 'malic_acid', 'ash', 'alcalinity_of_ash', 'magnesium', 'total_phenols', 'flavanoids', 'nonflavanoid_phenols', 'proanthocyanins', 'color_intensity', 'hue', 'od280/od315_of_diluted_wines', 'proline'] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "feature_names = dataset.feature_names\n",
    "print(f'feature_names = {feature_names} \\n') \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "99908eb5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of features to be selected = 4\n",
      "\n"
     ]
    }
   ],
   "source": [
    "k = 4\n",
    "print(f'number of features to be selected = {k}\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f45ad8e7",
   "metadata": {},
   "source": [
    "## (A) Feature selection with a quantum algorithm\n",
    "\n",
    "For feature selection, we are following the approach given in [arXiv:2104.04049](https://arxiv.org/abs/2104.04049) (see also, [arXiv:2203.13261](https://arxiv.org/abs/2203.13261)) where one can cast it as a \n",
    "\n",
    "__quadratic program (QP)__:\n",
    "$\\min_{\\bf{v}} \\bf{v}\\ Q\\ \\bf{v}$ where the binary vector $\\bf{v}$ carries decision variable $v_i$ for each feature $i$. \n",
    "$v_i = 1$ and $0$ mean $i$th feature is and is not selected, respectively.\n",
    "To select $k$ number of features, we put the constraint $\\sum_i v_i=k$.\n",
    "\n",
    "$Q$ is an upper triangular matrix.\n",
    "- The __off-diagonal__ entry $Q_{ij}$, $i<j$, is proportional to the Pearson correlation coefficient between features $x_i$ and $x_j$. A higher value of such a correlation is a signature of __redundancy__ that we want to minimize.\n",
    "\n",
    "- The __negative__ of __diagonal__ entry $-Q_{ii}$ is proportional to the Pearson correlation coefficient between features $x_i$ and target $y$. A higher value of such a correlation is a signature of __relevancy__ that we want to maximize.\n",
    "\n",
    "\n",
    "\n",
    "The QP can be turned into a Quadratic Unconstrained Binary Optimization (QUBO) problem that can be covered into an Ising Hamiltonian whose ground state represents the optimal solution. One can use different quantum algorithms to find a state close to the ground state as shown below.  \n",
    "\n",
    "\n",
    "### (A1a) Q matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "3b775a1c",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 288x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 288x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Pearson correlation coefficient between features x_i and x_j\n",
    "xx_pcc = np.corrcoef(X_train_.T)\n",
    "xx_pcc = np.abs(np.triu(xx_pcc, 1)) \n",
    "\n",
    "\n",
    "plt.matshow(xx_pcc, cmap='Reds')\n",
    "plt.xticks(np.arange(num_features))\n",
    "plt.yticks(np.arange(num_features))\n",
    "cb = plt.colorbar(shrink=0.7)\n",
    "plt.title('abs corr upp-tri matrix') \n",
    "plt.show()\n",
    "\n",
    "\n",
    "# Pearson correlation coefficient between feature x_i and target y\n",
    "xy_pcc = [np.abs(np.corrcoef(X_train_[:,l], y_train)[0,1]) for l in range(num_features)]\n",
    "\n",
    "\n",
    "# alpha is the weight attached to the off-diagonal terms,  0 <= alpha <=1\n",
    "# 1- alpha is the weight attached to the diagonal terms of Q\n",
    "alpha = 0.5\n",
    "\n",
    "Q = alpha*xx_pcc - (1-alpha)*np.diag(xy_pcc)\n",
    "\n",
    "\n",
    "def plot_Q_matrix():\n",
    "    plt.matshow(Q, cmap='bwr')\n",
    "    plt.xticks(np.arange(num_features))\n",
    "    plt.yticks(np.arange(num_features))\n",
    "    cb = plt.colorbar(shrink=0.7)\n",
    "    plt.title(f'Q matrix (alpha = {alpha})') \n",
    "    plt.show()\n",
    "\n",
    "plot_Q_matrix()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3d18775a",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit_optimization import QuadraticProgram                         #!pip install qiskit[optimization]\n",
    "\n",
    "from qiskit.algorithms.minimum_eigensolvers import SamplingVQE, NumPyMinimumEigensolver, QAOA\n",
    "from qiskit_optimization.algorithms import MinimumEigenOptimizer\n",
    "\n",
    "from qiskit_optimization.converters import QuadraticProgramToQubo\n",
    "from qiskit.primitives import Sampler\n",
    "from qiskit.circuit.library import TwoLocal\n",
    "from qiskit.algorithms.optimizers import SPSA, COBYLA"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0581c9a5",
   "metadata": {},
   "source": [
    "### (A1b) Quadratic Program using the Q matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "7ec32307",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<QuadraticProgram: minimize 0.043633758272574194*v0*v1 + 0.023714908751248903*..., 13 variables, 1 constraints, ''>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qp = QuadraticProgram()\n",
    "\n",
    "for i in range(num_features):\n",
    "    qp.binary_var(f'v{i}')\n",
    "\n",
    "    \n",
    "linear = [Q[i,i] for i in range(num_features)]\n",
    "\n",
    "quadratic = {}\n",
    "for i in range(num_features):\n",
    "    for j in range(i+1, num_features):\n",
    "        quadratic[(f'v{i}', f'v{j}')] = Q[i,j]\n",
    "        \n",
    "\n",
    "qp.minimize(linear=linear, quadratic=quadratic)\n",
    "\n",
    "\n",
    "linear_const = {f'v{i}':1 for i in range(num_features)}        # the constraint to select k number of features\n",
    "qp.linear_constraint(linear=linear_const, sense=\"==\", rhs=k, name=\"lin_const\")\n",
    "qp"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2c4c573",
   "metadata": {},
   "source": [
    "### (A2a) Feature selection by solving Quadratic Program with the exact classical eigensolver\n",
    "\n",
    "The class [__MinimumEigenOptimizer__](https://qiskit.org/ecosystem/optimization/stubs/qiskit_optimization.algorithms.MinimumEigenOptimizer.html) provides a wrapper for minimum eigen solvers from Qiskit to be used within the optimization module. It assumes a problem consisting only of binary or integer variables as well as linear equality constraints thereof. It converts such a problem into a QUBO problem by expanding integer variables into binary variables and by adding the linear equality constraints as weighted penalty terms to the objective function. The resulting QUBO is then translated into an Ising Hamiltonian whose minimal eigen vector and corresponding eigenstate correspond to the optimal solution of the original optimization problem. The provided minimum eigen solver is then used to approximate the ground state of the Hamiltonian to find a good solution for the optimization problem.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "ab750cda",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "objective function value: -0.44192253595886444\n",
      "variable values: v0=1.0, v1=0.0, v2=0.0, v3=0.0, v4=1.0, v5=0.0, v6=0.0, v7=0.0, v8=0.0, v9=0.0, v10=1.0, v11=1.0, v12=0.0\n",
      "status: SUCCESS\n",
      "\n",
      "CPU times: user 376 ms, sys: 0 ns, total: 376 ms\n",
      "Wall time: 374 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "exact = MinimumEigenOptimizer(min_eigen_solver=NumPyMinimumEigensolver())\n",
    "result = exact.solve(qp)\n",
    "print(result.prettyprint())\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f5c41b2",
   "metadata": {},
   "source": [
    "### (A2b) Feature selection by solving Quadratic Program with [VQE](https://qiskit.org/documentation/stubs/qiskit.algorithms.minimum_eigensolvers.SamplingVQE.html)\n",
    "\n",
    "VQE is a hybrid quantum-classical algorithm that uses a variational technique to find the minimum eigenvalue of a given diagonal Hamiltonian."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "82052f11",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "objective function value: -0.44192253595886444\n",
      "variable values: v0=1.0, v1=0.0, v2=0.0, v3=0.0, v4=1.0, v5=0.0, v6=0.0, v7=0.0, v8=0.0, v9=0.0, v10=1.0, v11=1.0, v12=0.0\n",
      "status: SUCCESS\n",
      "\n",
      "CPU times: user 11.4 s, sys: 124 ms, total: 11.6 s\n",
      "Wall time: 11.5 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "ansatz = TwoLocal(num_features, \"ry\", \"cz\", reps=3, entanglement=\"linear\")           # construct ansatz for VQE\n",
    "vqe = SamplingVQE(sampler=Sampler(), ansatz=ansatz, optimizer=COBYLA(maxiter=10))    # construct VQE\n",
    "\n",
    "\n",
    "meo_vqe = MinimumEigenOptimizer(min_eigen_solver=vqe)                                # run VQE\n",
    "result_vqe = meo_vqe.solve(qp)\n",
    "\n",
    "\n",
    "print(result_vqe.prettyprint())\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1381546e",
   "metadata": {},
   "source": [
    "### (A2c) Feature selection by solving Quadratic Program with [QAOA](https://qiskit.org/documentation/stubs/qiskit.algorithms.QAOA.html)\n",
    "\n",
    "The QAOA implementation directly extends VQE and inherits VQE’s optimization structure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "8babef62",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "objective function value: -0.44192253595886444\n",
      "variable values: v0=1.0, v1=0.0, v2=0.0, v3=0.0, v4=1.0, v5=0.0, v6=0.0, v7=0.0, v8=0.0, v9=0.0, v10=1.0, v11=1.0, v12=0.0\n",
      "status: SUCCESS\n",
      "\n",
      "CPU times: user 19.6 s, sys: 120 ms, total: 19.7 s\n",
      "Wall time: 19.7 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "qaoa = QAOA(sampler=Sampler(), optimizer=COBYLA(maxiter=10), reps=3)      # construct QAOA\n",
    "\n",
    "\n",
    "meo_qaoa = MinimumEigenOptimizer(min_eigen_solver=qaoa)                   # run QAOA\n",
    "result_qaoa = meo_qaoa.solve(qp)\n",
    "\n",
    "\n",
    "print(result_qaoa.prettyprint())\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ea5d2df",
   "metadata": {},
   "source": [
    "### (A2d) Feature selection by solving Quadratic Program with a classical greedy algorithm\n",
    "\n",
    "Here, the initial solution carries k ones and the rest zeros. A new solution is a random permutation of the last accepted solution. We accept the new solution if and only if the cost (energy) decreases. Hence, it is a classical greedy algorithm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6a5456dd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inital sol = [1 1 1 1 0 0 0 0 0 0 0 0 0]\n",
      "initial Emin = 0.133\n",
      "\n",
      "l =     0   Emin = -0.228   sol = [0 1 0 0 1 0 1 0 0 0 0 1 0]\n",
      "l =     1   Emin = -0.288   sol = [0 0 0 1 0 0 0 1 1 1 0 0 0]\n",
      "l =     3   Emin = -0.3   sol = [0 1 0 1 0 0 0 0 1 1 0 0 0]\n",
      "l =     5   Emin = -0.305   sol = [0 0 0 1 1 0 1 0 0 0 0 1 0]\n",
      "l =    29   Emin = -0.312   sol = [0 1 0 1 0 1 0 0 0 1 0 0 0]\n",
      "l =    56   Emin = -0.318   sol = [1 0 0 1 1 0 0 0 0 0 1 0 0]\n",
      "l =   130   Emin = -0.328   sol = [0 0 0 0 1 0 0 0 0 0 1 1 1]\n",
      "l =   209   Emin = -0.401   sol = [0 0 0 1 1 0 0 0 0 0 1 1 0]\n",
      "l =   309   Emin = -0.442   sol = [1 0 0 0 1 0 0 0 0 0 1 1 0]\n",
      "\n",
      "selected_feature_positions = [ 0  4 10 11]\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 288x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sol = np.append(np.ones(k, dtype=int), np.zeros(num_features-k, dtype=int))\n",
    "Emin = np.linalg.multi_dot([sol, Q , sol])\n",
    "\n",
    "print(f'inital sol = {sol}')\n",
    "print(f'initial Emin = {round(Emin,3)}\\n')\n",
    "       \n",
    "for l in range(10000):\n",
    "    s = np.random.permutation(sol)\n",
    "    E = np.linalg.multi_dot([s, Q , s])\n",
    "    if E < Emin:\n",
    "        sol, Emin = s, E\n",
    "        print(f'l = {l:5d}   Emin = {round(Emin,3)}   sol = {sol}')\n",
    "        \n",
    "        \n",
    "\n",
    "pos = np.where(sol==1)[0]\n",
    "print()\n",
    "print(f'selected_feature_positions = {pos}\\n')\n",
    "\n",
    "plot_Q_matrix()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d944b54",
   "metadata": {},
   "source": [
    "$ $\n",
    "\n",
    "## (B) Feature selection with sklearn based on mutual_info_classif"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "ca690a4a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "selected_features = ['flavanoids' 'color_intensity' 'hue' 'od280/od315_of_diluted_wines']\n",
      "\n",
      "selected_feature_positions = [6, 9, 10, 11]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.feature_selection import SelectKBest, mutual_info_classif\n",
    "\n",
    "\n",
    "f = SelectKBest(mutual_info_classif, k=4).fit(X_train_, y_train)\n",
    "selected_features = f.get_feature_names_out(feature_names)\n",
    "selected_features_pos = [np.where(np.array(feature_names) == sf)[0][0] for sf in selected_features]\n",
    "\n",
    "print(f'selected_features = {selected_features}\\n')\n",
    "print(f'selected_feature_positions = {selected_features_pos}\\n')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05281008",
   "metadata": {},
   "source": [
    "# After feature selection train and test sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "ff4d2f39",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "selected_feature_positions = [ 0  4 10 11]\n",
      "\n",
      "selected_features = ['alcohol' 'magnesium' 'hue' 'od280/od315_of_diluted_wines']\n",
      "\n",
      "number selected of features = k = 4: True\n"
     ]
    }
   ],
   "source": [
    "print(f'selected_feature_positions = {pos}\\n')\n",
    "print(f'selected_features = {np.array(feature_names)[pos]}\\n')\n",
    "\n",
    "X_train, X_test = X_train_[:,pos], X_test_[:,pos]\n",
    "\n",
    "   \n",
    "print(f\"number selected of features = k = {k}:\", k==X_train.shape[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bfe44f2",
   "metadata": {},
   "source": [
    "$ $\n",
    "\n",
    "# Classification with Quantum Machine Learning\n",
    "\n",
    "The following part is based on [the Qiskit Machine Learning tutorial](https://qiskit.org/ecosystem/machine-learning/tutorials/02a_training_a_quantum_model_on_a_real_dataset.html)\n",
    "\n",
    "\n",
    "## (1) Feature Map (FM): angle encoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "3032109e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">     ┌───┐┌─────────────┐                                               »\n",
       "q_0: ┤ H ├┤ P(2.0*x[0]) ├──■────────────────────────────────────■────■──»\n",
       "     ├───┤├─────────────┤┌─┴─┐┌──────────────────────────────┐┌─┴─┐  │  »\n",
       "q_1: ┤ H ├┤ P(2.0*x[1]) ├┤ X ├┤ P(2.0*(π - x[0])*(π - x[1])) ├┤ X ├──┼──»\n",
       "     ├───┤├─────────────┤└───┘└──────────────────────────────┘└───┘┌─┴─┐»\n",
       "q_2: ┤ H ├┤ P(2.0*x[2]) ├──────────────────────────────────────────┤ X ├»\n",
       "     ├───┤├─────────────┤                                          └───┘»\n",
       "q_3: ┤ H ├┤ P(2.0*x[3]) ├───────────────────────────────────────────────»\n",
       "     └───┘└─────────────┘                                               »\n",
       "«                                                    »\n",
       "«q_0: ──────────────────────────────────■─────────■──»\n",
       "«                                       │         │  »\n",
       "«q_1: ──────────────────────────────────┼────■────┼──»\n",
       "«     ┌──────────────────────────────┐┌─┴─┐┌─┴─┐  │  »\n",
       "«q_2: ┤ P(2.0*(π - x[0])*(π - x[2])) ├┤ X ├┤ X ├──┼──»\n",
       "«     └──────────────────────────────┘└───┘└───┘┌─┴─┐»\n",
       "«q_3: ──────────────────────────────────────────┤ X ├»\n",
       "«                                               └───┘»\n",
       "«                                                    »\n",
       "«q_0: ───────────────────────────────────────■───────»\n",
       "«                                            │       »\n",
       "«q_1: ──────────────────────────────────■────┼────■──»\n",
       "«     ┌──────────────────────────────┐┌─┴─┐  │    │  »\n",
       "«q_2: ┤ P(2.0*(π - x[1])*(π - x[2])) ├┤ X ├──┼────┼──»\n",
       "«     ├──────────────────────────────┤└───┘┌─┴─┐┌─┴─┐»\n",
       "«q_3: ┤ P(2.0*(π - x[0])*(π - x[3])) ├─────┤ X ├┤ X ├»\n",
       "«     └──────────────────────────────┘     └───┘└───┘»\n",
       "«                                               »\n",
       "«q_0: ──────────────────────────────────────────»\n",
       "«                                               »\n",
       "«q_1: ──────────────────────────────────■───────»\n",
       "«                                       │       »\n",
       "«q_2: ──────────────────────────────────┼────■──»\n",
       "«     ┌──────────────────────────────┐┌─┴─┐┌─┴─┐»\n",
       "«q_3: ┤ P(2.0*(π - x[1])*(π - x[3])) ├┤ X ├┤ X ├»\n",
       "«     └──────────────────────────────┘└───┘└───┘»\n",
       "«                                          \n",
       "«q_0: ─────────────────────────────────────\n",
       "«                                          \n",
       "«q_1: ─────────────────────────────────────\n",
       "«                                          \n",
       "«q_2: ──────────────────────────────────■──\n",
       "«     ┌──────────────────────────────┐┌─┴─┐\n",
       "«q_3: ┤ P(2.0*(π - x[2])*(π - x[3])) ├┤ X ├\n",
       "«     └──────────────────────────────┘└───┘</pre>"
      ],
      "text/plain": [
       "     ┌───┐┌─────────────┐                                               »\n",
       "q_0: ┤ H ├┤ P(2.0*x[0]) ├──■────────────────────────────────────■────■──»\n",
       "     ├───┤├─────────────┤┌─┴─┐┌──────────────────────────────┐┌─┴─┐  │  »\n",
       "q_1: ┤ H ├┤ P(2.0*x[1]) ├┤ X ├┤ P(2.0*(π - x[0])*(π - x[1])) ├┤ X ├──┼──»\n",
       "     ├───┤├─────────────┤└───┘└──────────────────────────────┘└───┘┌─┴─┐»\n",
       "q_2: ┤ H ├┤ P(2.0*x[2]) ├──────────────────────────────────────────┤ X ├»\n",
       "     ├───┤├─────────────┤                                          └───┘»\n",
       "q_3: ┤ H ├┤ P(2.0*x[3]) ├───────────────────────────────────────────────»\n",
       "     └───┘└─────────────┘                                               »\n",
       "«                                                    »\n",
       "«q_0: ──────────────────────────────────■─────────■──»\n",
       "«                                       │         │  »\n",
       "«q_1: ──────────────────────────────────┼────■────┼──»\n",
       "«     ┌──────────────────────────────┐┌─┴─┐┌─┴─┐  │  »\n",
       "«q_2: ┤ P(2.0*(π - x[0])*(π - x[2])) ├┤ X ├┤ X ├──┼──»\n",
       "«     └──────────────────────────────┘└───┘└───┘┌─┴─┐»\n",
       "«q_3: ──────────────────────────────────────────┤ X ├»\n",
       "«                                               └───┘»\n",
       "«                                                    »\n",
       "«q_0: ───────────────────────────────────────■───────»\n",
       "«                                            │       »\n",
       "«q_1: ──────────────────────────────────■────┼────■──»\n",
       "«     ┌──────────────────────────────┐┌─┴─┐  │    │  »\n",
       "«q_2: ┤ P(2.0*(π - x[1])*(π - x[2])) ├┤ X ├──┼────┼──»\n",
       "«     ├──────────────────────────────┤└───┘┌─┴─┐┌─┴─┐»\n",
       "«q_3: ┤ P(2.0*(π - x[0])*(π - x[3])) ├─────┤ X ├┤ X ├»\n",
       "«     └──────────────────────────────┘     └───┘└───┘»\n",
       "«                                               »\n",
       "«q_0: ──────────────────────────────────────────»\n",
       "«                                               »\n",
       "«q_1: ──────────────────────────────────■───────»\n",
       "«                                       │       »\n",
       "«q_2: ──────────────────────────────────┼────■──»\n",
       "«     ┌──────────────────────────────┐┌─┴─┐┌─┴─┐»\n",
       "«q_3: ┤ P(2.0*(π - x[1])*(π - x[3])) ├┤ X ├┤ X ├»\n",
       "«     └──────────────────────────────┘└───┘└───┘»\n",
       "«                                          \n",
       "«q_0: ─────────────────────────────────────\n",
       "«                                          \n",
       "«q_1: ─────────────────────────────────────\n",
       "«                                          \n",
       "«q_2: ──────────────────────────────────■──\n",
       "«     ┌──────────────────────────────┐┌─┴─┐\n",
       "«q_3: ┤ P(2.0*(π - x[2])*(π - x[3])) ├┤ X ├\n",
       "«     └──────────────────────────────┘└───┘"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit.circuit.library import PauliFeatureMap, ZFeatureMap, ZZFeatureMap\n",
    "\n",
    "\n",
    "fm = ZZFeatureMap(feature_dimension=k, reps=1)                  \n",
    "fm.decompose().draw() \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5095dcbb",
   "metadata": {},
   "source": [
    "## (2) Parameterized Quantum Circuit (PQC)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "09033fdc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">     ┌──────────┐                             ┌──────────┐             »\n",
       "q_0: ┤ Ry(θ[0]) ├──────────────────────■──────┤ Ry(θ[4]) ├─────────────»\n",
       "     ├──────────┤                    ┌─┴─┐    ├──────────┤             »\n",
       "q_1: ┤ Ry(θ[1]) ├──────────■─────────┤ X ├────┤ Ry(θ[5]) ├──────■──────»\n",
       "     ├──────────┤        ┌─┴─┐    ┌──┴───┴───┐└──────────┘    ┌─┴─┐    »\n",
       "q_2: ┤ Ry(θ[2]) ├──■─────┤ X ├────┤ Ry(θ[6]) ├─────■──────────┤ X ├────»\n",
       "     ├──────────┤┌─┴─┐┌──┴───┴───┐└──────────┘   ┌─┴─┐    ┌───┴───┴───┐»\n",
       "q_3: ┤ Ry(θ[3]) ├┤ X ├┤ Ry(θ[7]) ├───────────────┤ X ├────┤ Ry(θ[11]) ├»\n",
       "     └──────────┘└───┘└──────────┘               └───┘    └───────────┘»\n",
       "«                  ┌──────────┐                          ┌───────────┐\n",
       "«q_0: ──────■──────┤ Ry(θ[8]) ├───────────────────■──────┤ Ry(θ[12]) ├\n",
       "«         ┌─┴─┐    ├──────────┤                 ┌─┴─┐    ├───────────┤\n",
       "«q_1: ────┤ X ├────┤ Ry(θ[9]) ├──────■──────────┤ X ├────┤ Ry(θ[13]) ├\n",
       "«     ┌───┴───┴───┐└──────────┘    ┌─┴─┐    ┌───┴───┴───┐└───────────┘\n",
       "«q_2: ┤ Ry(θ[10]) ├─────■──────────┤ X ├────┤ Ry(θ[14]) ├─────────────\n",
       "«     └───────────┘   ┌─┴─┐    ┌───┴───┴───┐└───────────┘             \n",
       "«q_3: ────────────────┤ X ├────┤ Ry(θ[15]) ├──────────────────────────\n",
       "«                     └───┘    └───────────┘                          </pre>"
      ],
      "text/plain": [
       "     ┌──────────┐                             ┌──────────┐             »\n",
       "q_0: ┤ Ry(θ[0]) ├──────────────────────■──────┤ Ry(θ[4]) ├─────────────»\n",
       "     ├──────────┤                    ┌─┴─┐    ├──────────┤             »\n",
       "q_1: ┤ Ry(θ[1]) ├──────────■─────────┤ X ├────┤ Ry(θ[5]) ├──────■──────»\n",
       "     ├──────────┤        ┌─┴─┐    ┌──┴───┴───┐└──────────┘    ┌─┴─┐    »\n",
       "q_2: ┤ Ry(θ[2]) ├──■─────┤ X ├────┤ Ry(θ[6]) ├─────■──────────┤ X ├────»\n",
       "     ├──────────┤┌─┴─┐┌──┴───┴───┐└──────────┘   ┌─┴─┐    ┌───┴───┴───┐»\n",
       "q_3: ┤ Ry(θ[3]) ├┤ X ├┤ Ry(θ[7]) ├───────────────┤ X ├────┤ Ry(θ[11]) ├»\n",
       "     └──────────┘└───┘└──────────┘               └───┘    └───────────┘»\n",
       "«                  ┌──────────┐                          ┌───────────┐\n",
       "«q_0: ──────■──────┤ Ry(θ[8]) ├───────────────────■──────┤ Ry(θ[12]) ├\n",
       "«         ┌─┴─┐    ├──────────┤                 ┌─┴─┐    ├───────────┤\n",
       "«q_1: ────┤ X ├────┤ Ry(θ[9]) ├──────■──────────┤ X ├────┤ Ry(θ[13]) ├\n",
       "«     ┌───┴───┴───┐└──────────┘    ┌─┴─┐    ┌───┴───┴───┐└───────────┘\n",
       "«q_2: ┤ Ry(θ[10]) ├─────■──────────┤ X ├────┤ Ry(θ[14]) ├─────────────\n",
       "«     └───────────┘   ┌─┴─┐    ┌───┴───┴───┐└───────────┘             \n",
       "«q_3: ────────────────┤ X ├────┤ Ry(θ[15]) ├──────────────────────────\n",
       "«                     └───┘    └───────────┘                          "
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit.circuit.library import RealAmplitudes\n",
    "\n",
    "\n",
    "pqc = RealAmplitudes(num_qubits=k, reps=3)\n",
    "pqc.decompose().draw()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "039a10b8",
   "metadata": {},
   "source": [
    "## (3) Build the model: [Variational Quantum Classifier (VQC)](https://qiskit.org/documentation/stable/0.19/stubs/qiskit.aqua.algorithms.VQC.html#qiskit.aqua.algorithms.VQC) with FM and PQC\n",
    "\n",
    "\n",
    "__[Sampler](https://qiskit.org/documentation/apidoc/primitives.html) class calculates probabilities or quasi-probabilities of bitstrings from quantum circuits.__\n",
    "A sampler is initialized with an empty parameter set. The sampler is used to create a JobV1, via the qiskit.primitives.Sampler.run() method, and yields a SamplerResult object, which contains probabilities or quasi-probabilities of bitstrings, plus optional metadata like error bars in the samples.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "092d8331",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.algorithms.optimizers import COBYLA\n",
    "\n",
    "# This defines where to train our classifier: on a simulator or a real quantum computer\n",
    "from qiskit.primitives import Sampler                             # here we have chosen a simulator \n",
    "\n",
    "from qiskit_machine_learning.algorithms.classifiers import VQC    # !pip install qiskit[machine-learning]\n",
    "\n",
    "\n",
    "#------------------------------------------------------------------------------------------------\n",
    "\n",
    "optimizer = COBYLA(maxiter=250)                 # maxiter = Maximum number of iterations (function evaluations)\n",
    "sampler = Sampler()\n",
    "\n",
    "#------------------------------------------------------------------------------------------------\n",
    "\n",
    "from IPython.display import clear_output\n",
    "objective_func_vals = []\n",
    "                                    # a callback that can access the intermediate data during the optimization\n",
    "def callback(weights, obj_func_eval):\n",
    "    clear_output(wait=True)\n",
    "    objective_func_vals.append(obj_func_eval)\n",
    "    plt.xlabel(\"Iteration\")\n",
    "    plt.ylabel(\"Objective function value\")\n",
    "    plt.plot(range(len(objective_func_vals)), objective_func_vals)\n",
    "    plt.show()\n",
    "\n",
    "#------------------------------------------------------------------------------------------------\n",
    "\n",
    "vqc = VQC(\n",
    "    sampler=sampler,\n",
    "    feature_map=fm,\n",
    "    ansatz=pqc,\n",
    "    optimizer=optimizer,\n",
    "    callback=callback,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0169855d",
   "metadata": {},
   "source": [
    "## (4) Training VQC ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "7d8a6f94",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "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": [
      "CPU times: user 3min 41s, sys: 45.6 s, total: 4min 27s\n",
      "Wall time: 3min 29s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<qiskit_machine_learning.algorithms.classifiers.vqc.VQC at 0x7f19faeb3dc0>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "'''Training time increases with the number of features'''\n",
    "\n",
    "vqc.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c7185a9",
   "metadata": {},
   "source": [
    "## (5) performance evaluation of trained VQC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "afd4b48d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "VQC train score: 0.83\n",
      "VQC test score:  0.80\n"
     ]
    }
   ],
   "source": [
    "train_score = vqc.score(X_train, y_train)\n",
    "test_score = vqc.score(X_test, y_test)\n",
    "\n",
    "print(f\"VQC train score: {train_score:.2f}\")\n",
    "print(f\"VQC test score:  {test_score:.2f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f474951d",
   "metadata": {},
   "source": [
    "$ $\n",
    "\n",
    "$ $\n",
    "\n",
    "# Classification with Classical Machine Learning (ML) models with [scikit-learn](https://scikit-learn.org/stable/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "a1bfb347",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------- LogisticRegression() --------------- \n",
      "\n",
      "ML train score: 0.91\n",
      "ML test score:  0.96\n",
      "\n",
      "--------------- MLPClassifier() --------------- \n",
      "\n",
      "ML train score: 0.92\n",
      "ML test score:  0.94\n",
      "\n",
      "--------------- SVC() --------------- \n",
      "\n",
      "ML train score: 0.94\n",
      "ML test score:  0.94\n",
      "\n",
      "--------------- RandomForestClassifier() --------------- \n",
      "\n",
      "ML train score: 1.00\n",
      "ML test score:  0.98\n",
      "\n",
      "CPU times: user 235 ms, sys: 2.96 ms, total: 237 ms\n",
      "Wall time: 255 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "def train_test(ML_model):\n",
    "    print(15*'-', ML_model, 15*'-','\\n')\n",
    "    ML_model.fit(X_train, y_train)                          # fit model\n",
    "    \n",
    "    train_score_ML = ML_model.score(X_train, y_train)       # evaluate model\n",
    "    test_score_ML = ML_model.score(X_test, y_test)\n",
    "    \n",
    "    print(f\"ML train score: {train_score_ML:.2f}\")\n",
    "    print(f\"ML test score:  {test_score_ML:.2f}\")\n",
    "\n",
    "    print()\n",
    "    \n",
    "\n",
    "#----------------------------------------------------------------------------------\n",
    "\n",
    "\n",
    "ML_model = linear_model.LogisticRegression()              # create model instance\n",
    "train_test(ML_model)\n",
    "\n",
    "\n",
    "ML_model = MLPClassifier()                            \n",
    "train_test(ML_model)\n",
    "\n",
    "\n",
    "ML_model = svm.SVC() \n",
    "train_test(ML_model)\n",
    "\n",
    "\n",
    "ML_model = RandomForestClassifier()\n",
    "train_test(ML_model)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d7defb0a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0997130b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c040ab6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ba0b9f67",
   "metadata": {},
   "source": [
    "# $ $\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "$ $"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}