quantum_model_MERA_1_layers_noise.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quantum model\n",
    "\n",
    "The fair model is designed from the data set that was made in the data analysis section and his can compare with the classical fair model, for this will be with the use of neural networks to predict when there is a backorder and thus pass the data to the company responsible for the distribution and storage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "fKJm0SmcDpUD",
    "outputId": "93105aae-e162-4f7b-eb9e-100cce222d6d"
   },
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "In case you don't have installed tensorflow uncomment the following cell"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#pip install pennyane"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Callign the dependencies fro mpennylane the optimizers, and methods to generate a quantum circuit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "cK5Ry9dADtir",
    "outputId": "b438ff3d-7cc8-45f8-e3db-1d436e81c1c6"
   },
   "outputs": [],
   "source": [
    "#improt pennylane dependnecies\n",
    "import pennylane as qml\n",
    "from pennylane import numpy as np\n",
    "from pennylane.optimize import NesterovMomentumOptimizer\n",
    "\n",
    "\n",
    "# load the csv files\n",
    "import pandas as pd\n",
    "\n",
    "# plot the historical acc and cost\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "\n",
    "\n",
    "from IPython.display import clear_output\n",
    "clear_output(wait=False)\n",
    "\n",
    "import os\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load the train and test sets from the Data analysis module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "ZTdT7iH2DpUG"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(((2000, 16), (2000,)), ((6159, 16), (6159,)))"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_train = pd.read_csv(\"dataset/fair_train.csv\")\n",
    "X_train,y_train = data_train[data_train.columns[:16]].values, data_train[data_train.columns[16]].values\n",
    "\n",
    "data_test = pd.read_csv(\"dataset/classic_test.csv\")\n",
    "X_test,y_test = data_test[data_test.columns[:16]].values, data_test[data_test.columns[16]].values\n",
    "\n",
    "(X_train.shape, y_train.shape),(X_test.shape, y_test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Init the device that called the backend default.qubit and using 4 qubits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "s804AwFCEFV8"
   },
   "outputs": [],
   "source": [
    "n_wires = 4\n",
    "dev = qml.device(\"default.mixed\", wires=n_wires)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define the structure of the entenglament for MERA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def block(weights, wires):\n",
    "    qml.CNOT(wires=[wires[0],wires[1]])\n",
    "    qml.RY(weights[0], wires=wires[0])\n",
    "    qml.RY(weights[1], wires=wires[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define the parameters for MERA quantum circuit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_block_wires = 2\n",
    "n_params_block = 2\n",
    "n_blocks = qml.MERA.get_n_blocks(range(n_wires),n_block_wires)\n",
    "n_blocks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Called the quantum circuit for all the data train using amplitude embedding, where the  data is encoded into the amplitudes of a quantum state. A normalized classical $N$ -dimensional datapoint $x$ is represented by the amplitudes of a $n$-qubit quantum state $\\left|\\psi_{x}\\right\\rangle$ as\n",
    "$$\n",
    "\\left|\\psi_{x}\\right\\rangle=\\sum_{i=1}^{N} x_{i}|i\\rangle\n",
    "$$\n",
    "where $N=2^{n}, x_{i}$ is the $i$-th element of $x$, and $|i\\rangle$ is the $i$-th computational basis state. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "P2gS_r0dEN5s"
   },
   "outputs": [],
   "source": [
    "@qml.qnode(dev)\n",
    "@qml.transforms.insert(qml.AmplitudeDamping, 0.2, position=\"end\")\n",
    "def circuit(weights, x):\n",
    "\n",
    "    qml.AmplitudeEmbedding(x, wires=[0,1,2,3],normalize=True,pad_with=True)\n",
    "\n",
    "    for w in weights:\n",
    "\n",
    "        qml.MERA(range(n_wires),n_block_wires,block, n_params_block, w)\n",
    "        #print(w)\n",
    "    #print(x)\n",
    "    \n",
    "    return qml.expval(qml.PauliZ(1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "xLSeVH8CEPUi"
   },
   "outputs": [],
   "source": [
    "def variational_classifier(weights, bias, x):\n",
    "    return circuit(weights, x) + bias\n",
    "\n",
    "def square_loss(labels, predictions):\n",
    "    loss = 0\n",
    "    for l, p in zip(labels, predictions):\n",
    "        loss = loss + (l - p) ** 2\n",
    "\n",
    "    loss = loss / len(labels)\n",
    "    return loss\n",
    "def accuracy(labels, predictions):\n",
    "\n",
    "    loss = 0\n",
    "    for l, p in zip(labels, predictions):\n",
    "        if abs(l - p) < 1e-5:\n",
    "            loss = loss + 1\n",
    "    loss = loss / len(labels)\n",
    "\n",
    "    return loss\n",
    "\n",
    "def cost(weights, bias, X, Y):\n",
    "    #print(1)\n",
    "    predictions = [variational_classifier(weights, bias, x) for x in X]\n",
    "    return square_loss(Y, predictions)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "yFN174tZEU22",
    "outputId": "7de4359e-7953-487e-8f08-30a7623d639e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[11.08386778  2.51426189]\n",
      "  [ 6.14959212 14.07994722]\n",
      "  [11.73421292 -6.14041802]\n",
      "  [ 5.96958159 -0.95100539]\n",
      "  [-0.64854317  2.57986647]]] 0.0\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(0)\n",
    "num_layers = 1\n",
    "weights_init = 2*np.pi * np.random.randn(num_layers,n_blocks, n_params_block, requires_grad=True)\n",
    "bias_init = np.array(0.0, requires_grad=True)\n",
    "\n",
    "print(weights_init, bias_init)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: ─╭QubitStateVector(M0)─╭X──RY(2.51)────────────────╭●───────────────────────RY(5.97)─\n",
      "1: ─├QubitStateVector(M0)─╰●──RY(11.08)─╭X──RY(-6.14)─│─────────────────────────────────\n",
      "2: ─├QubitStateVector(M0)─╭●──RY(6.15)──│─────────────╰X───────────────────────RY(-0.95)\n",
      "3: ─╰QubitStateVector(M0)─╰X──RY(14.08)─╰●──RY(11.73)──AmplitudeDamping(0.20)───────────\n",
      "\n",
      "──╭●───────────────────────RY(-0.65)──AmplitudeDamping(0.20)─┤     \n",
      "──╰X───────────────────────RY(2.58)───AmplitudeDamping(0.20)─┤  <Z>\n",
      "───AmplitudeDamping(0.20)────────────────────────────────────┤     \n",
      "─────────────────────────────────────────────────────────────┤     \n"
     ]
    }
   ],
   "source": [
    " print(qml.draw(circuit,expansion_strategy='device',wire_order=[0,1,2,3])(weights_init,np.asarray(X_train[0])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "g2IhcVFlEV_V",
    "outputId": "3b78e6fc-f121-4095-a4b3-47e1b07ce621"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11.08386778  2.51426189]\n"
     ]
    }
   ],
   "source": [
    "for i in weights_init:\n",
    "    print(i[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "1WEWkuIOEXnm"
   },
   "outputs": [],
   "source": [
    "y_train = np.where(y_train < 1, -1, y_train)\n",
    "y_test = np.where(y_test < 1, -1, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "Vrs1X5UiMnWJ"
   },
   "outputs": [],
   "source": [
    "from sklearn.utils import shuffle\n",
    "X,y = shuffle(X_train, y_train, random_state=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "s8Z8HLOXEY1n",
    "outputId": "249d3445-bac4-4885-8c86-49053fd8b78a"
   },
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "opt = NesterovMomentumOptimizer(0.4)\n",
    "batch_size = 32\n",
    "\n",
    "num_data = len(y_train)\n",
    "num_train = 0.9\n",
    "# train the variational classifier\n",
    "weights = weights_init\n",
    "bias = bias_init\n",
    "print()\n",
    "\n",
    "cost_g = []\n",
    "acc_train = []\n",
    "acc_test = []\n",
    "plt.show()\n",
    "for it in range(50):\n",
    "    X_train_70, X_test_30, y_train_70, y_test_30 =train_test_split(np.asarray(X), np.asarray(y), train_size=num_train, test_size=1.0-num_train, shuffle=True)\n",
    "    # Update the weights by one optimizer step\n",
    "    batch_index = np.random.randint(0, len(X_train_70), (batch_size,))\n",
    "    feats_train_batch = X_train_70[batch_index]\n",
    "    Y_train_batch = y_train_70[batch_index]\n",
    "    weights, bias, _, _ = opt.step(cost, weights, bias, feats_train_batch, Y_train_batch)\n",
    "\n",
    "    # Compute predictions on train and validation set\n",
    "    predictions_train = [np.sign(variational_classifier(weights, bias, f)) for f in X_train_70]\n",
    "    predictions_val = [np.sign(variational_classifier(weights, bias, f)) for f in X_test_30]\n",
    "    # Compute accuracy on train and validation set\n",
    "    acc_tra = accuracy(y_train_70, predictions_train)\n",
    "    acc_val = accuracy(y_test_30, predictions_val)\n",
    "    cost_train = cost(weights, bias,X_train, y_train)\n",
    "    cost_g.append(cost_train)\n",
    "    \n",
    "    acc_train.append(acc_tra)\n",
    "    acc_test.append(acc_val)\n",
    "    \n",
    "    clear_output(wait=True)\n",
    "    plt.plot(cost_g,label='cost')\n",
    "    plt.plot(acc_train,label='acc_train')\n",
    "    plt.plot(acc_test,label='acc_test')\n",
    "    plt.legend(['cost','acc_train','acc_test'])\n",
    "    plt.show()\n",
    "     \n",
    "    \n",
    "    print(\n",
    "         \"Iter: {:5d} | Cost: {:0.7f} | Acc train: {:0.7f} | Acc validation: {:0.7f} \"\n",
    "         \"\".format(it + 1, cost_train, acc_tra, acc_val)\n",
    "     )\n",
    "    print(weights)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.4423974 , 0.5898632 , 0.        , 0.        , 0.        ,\n",
       "       0.        , 0.        , 0.1474658 , 0.2949316 , 0.4423974 ,\n",
       "       0.3686645 , 0.        , 0.07225824, 0.07299557, 0.        ,\n",
       "       0.0737329 ])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_test = []\n",
    "for x in X_test.tolist():\n",
    "    if sum(x) == 0:\n",
    "        x[0]=1\n",
    "    x_test.append( x/ np.linalg.norm(x))\n",
    "x_test[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([-1, -1, -1, ...,  1,  1,  1], requires_grad=True)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = [np.sign(variational_classifier(weights, bias, f)) for f in x_test]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_test_pred = []\n",
    "for i in y_pred:\n",
    "    if i < 0:\n",
    "        y_test_pred.append(-1)\n",
    "    else:\n",
    "        y_test_pred.append(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.767495\n",
      "Precision: 0.427408\n",
      "Recall: 0.790080\n",
      "F1 score: 0.554726\n",
      "Cohens kappa: 0.415717\n",
      "ROC AUC: 0.776253\n",
      "[[3835 1195]\n",
      " [ 237  892]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "from sklearn.metrics import confusion_matrix, roc_curve, auc\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "# demonstration of calculating metrics for a neural network model using sklearn\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.metrics import precision_score\n",
    "from sklearn.metrics import recall_score\n",
    "from sklearn.metrics import f1_score\n",
    "from sklearn.metrics import cohen_kappa_score\n",
    "from sklearn.metrics import roc_auc_score\n",
    "\n",
    "accuracy = accuracy_score(y_test, y_test_pred)\n",
    "print('Accuracy: %f' % accuracy)\n",
    "# precision tp / (tp + fp)\n",
    "precision = precision_score(y_test, y_test_pred)\n",
    "print('Precision: %f' % precision)\n",
    "# recall: tp / (tp + fn)\n",
    "recall = recall_score(y_test, y_test_pred)\n",
    "print('Recall: %f' % recall)\n",
    "# f1: 2 tp / (2 tp + fp + fn)\n",
    "f1 = f1_score(y_test, y_test_pred)\n",
    "print('F1 score: %f' % f1)\n",
    " \n",
    "# kappa\n",
    "kappa = cohen_kappa_score(y_test, y_test_pred)\n",
    "print('Cohens kappa: %f' % kappa)\n",
    "# ROC AUC\n",
    "auc = roc_auc_score(y_test, y_test_pred)\n",
    "print('ROC AUC: %f' % auc)\n",
    "# confusion matrix\n",
    "test_matrix = confusion_matrix(y_test, y_test_pred)\n",
    "print(test_matrix)\n",
    "ax = sns.heatmap(test_matrix, annot=True, cmap='Blues', fmt='g')\n",
    "\n",
    "ax.set_title('Seaborn Confusion Matrix with labels\\n\\n');\n",
    "ax.set_xlabel('\\nPredicted Values')\n",
    "ax.set_ylabel('Actual Values ');\n",
    "\n",
    "ax.xaxis.set_ticklabels(['0','1'])\n",
    "ax.yaxis.set_ticklabels(['0','1'])\n",
    "\n",
    "## Display the visualization of the Confusion Matrix.\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_1 = [int(i) for i in y_test_pred ]\n",
    "y_pred_1 = [\"{}\\n\".format(i) for i in y_pred_1]\n",
    "with open(r'mera_1_layers_noise.csv', 'w') as fp:\n",
    "    fp.writelines(y_pred_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "name": "classic_BackOrders_accuracy_1_v4.ipynb",
   "provenance": []
  },
  "gpuClass": "standard",
  "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.8.13"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}