From 4b95ed609bd9e634fac5d96667a54d18f4e7ebde Mon Sep 17 00:00:00 2001 From: Amer Delilbasic <amer.delilbasic@studenti.unitn.it> Date: Wed, 14 Jul 2021 11:49:09 +0000 Subject: [PATCH] Upload New File --- experiments/Circuit_SVM/Circuit_SVM.ipynb | 445 ++++++++++++++++++++++ 1 file changed, 445 insertions(+) create mode 100644 experiments/Circuit_SVM/Circuit_SVM.ipynb diff --git a/experiments/Circuit_SVM/Circuit_SVM.ipynb b/experiments/Circuit_SVM/Circuit_SVM.ipynb new file mode 100644 index 0000000..881c240 --- /dev/null +++ b/experiments/Circuit_SVM/Circuit_SVM.ipynb @@ -0,0 +1,445 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Classification with SVM on the IBM QASM Simulator\n", + "## Circuit SVM Code" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Import Packages" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import glob\n", + "from utils_updated import *\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib import colors\n", + "from sklearn import preprocessing\n", + "from sklearn.svm import SVC\n", + "\n", + "from sklearn.metrics import accuracy_score\n", + "from sklearn.metrics import f1_score\n", + "\n", + "from qiskit import BasicAer, IBMQ\n", + "from qiskit.circuit.library import ZZFeatureMap, PauliFeatureMap\n", + "from qiskit.aqua import QuantumInstance, aqua_globals\n", + "from qiskit.aqua.algorithms import QSVM\n", + "from qiskit.aqua.utils import split_dataset_to_data_and_labels, map_label_to_class_name\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load the training and test sets" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X_train (50, 8)\n", + "Y_train (50,)\n", + "X_test (250000, 8)\n", + "Y_test (250000,)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Load training set\n", + "key='_tiny'\n", + "X_train=np.load('X_train_tile_4'+key+'.npy')\n", + "Y_train=np.load('Y_train_tile_4'+key+'.npy')\n", + "\n", + "print('X_train',X_train.shape) \n", + "print('Y_train',Y_train.shape) \n", + "\n", + "# Load test set\n", + "X_test=np.load('X_test_tile_8_subregion.npy')\n", + "Y_test=np.load('Y_test_tile_8_subregion.npy')\n", + "\n", + "print('X_test',X_test.shape) \n", + "print('Y_test',Y_test.shape) \n", + "\n", + "# If {-1,1} is required:\n", + "# Y_train=np.where(Y_train==0,-1,Y_train)\n", + "\n", + "groundtruth=np.reshape(Y_test,(500,500))\n", + "plt.title('Groundtruth')\n", + "cmap = colors.ListedColormap(['black', 'red'])\n", + "plt.rcParams[\"figure.figsize\"] = (5,5)\n", + "view=plt.imshow(groundtruth,cmap=cmap)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Option 1: selected a NxN window as test set\n", + "This training set has shown the best results." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(225, 8) (225,)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 360x360 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "N=15\n", + "start=251\n", + "X_test2 = np.reshape(X_test,(500,500,8))\n", + "X_test2 = X_test2[start:start+N,0:N]\n", + "Y_test2 = groundtruth[start:start+N,0:N]\n", + "plt.imshow(Y_test2, cmap=cmap)\n", + "X_test2 = np.reshape(X_test2, (N*N,8))\n", + "Y_test2 = np.squeeze(np.reshape(Y_test2, (N*N,1)))\n", + "print(X_test2.shape,Y_test2.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Option 2: select N random pixels as test set" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "N=100\n", + "#random_indices = np.random.choice(X_test.shape[0],size=N,replace=False)\n", + "X_test_0_indices = [i for i, y in enumerate(Y_test) if y == 0]\n", + "X_test_1_indices = [i for i, y in enumerate(Y_test) if y == 1]\n", + "\n", + "random_indices_0 = np.random.choice(len(X_test_0_indices),size=N,replace=False)\n", + "random_indices_1 = np.random.choice(len(X_test_1_indices),size=N,replace=False)\n", + "#print(random_indices_0,random_indices_1)\n", + "#print(np.take(X_test_0_indices, random_indices_0))\n", + "X_test2 = np.append(X_test[np.take(X_test_0_indices, random_indices_0),:], X_test[np.take(X_test_1_indices, random_indices_1),:], axis=0)\n", + "Y_test2 = np.append(Y_test[np.take(X_test_0_indices, random_indices_0)], Y_test[np.take(X_test_1_indices, random_indices_1)])\n", + "#print(X_test2,Y_test2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Quantum enhanced SVM (circuit based)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `'TOKEN'` string can be copied from the personal IBM Quantum Experience account." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "token='TOKEN'\n", + "#IBMQ.save_account(token)\n", + "provider = IBMQ.load_account()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Block for dimensionality reduction. `feature_dim = 8` keeps the samples unchanged." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.decomposition import PCA\n", + "\n", + "feature_dim = 8\n", + "pca = PCA(feature_dim)\n", + "X_train = pca.fit_transform(X_train)\n", + "X_test = pca.fit_transform(X_test)\n", + "X_test2 = pca.fit_transform(X_test2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Block for training dataset creation." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "X_train_0_indices = [i for i, y in enumerate(Y_train) if y == 0]\n", + "X_train_1_indices = [i for i, y in enumerate(Y_train) if y == 1]\n", + "training_input = {'0': X_train[X_train_0_indices], '1': X_train[X_train_1_indices]}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The QSVM function needs a test dataset and a prediction dataset. Since for the test dataset only the accuracy is computed, and we need a plot of the results, we use the sub-image as a prediction dataset and keep only a small number of samples for the test dataset to lower the time overhead." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "X_test_0_indices = [i for i, y in enumerate(Y_test) if y == 0]\n", + "X_test_1_indices = [i for i, y in enumerate(Y_test) if y == 1]\n", + "number_test_samples = 20\n", + "X_test_0_indices = X_test_0_indices[0:number_test_samples]\n", + "X_test_1_indices = X_test_1_indices[0:number_test_samples]\n", + "test_input = {'0': X_test[X_test_0_indices], '1': X_test[X_test_1_indices]}\n", + "class_labels = [0,1]\n", + "datapoints = [X_test2, Y_test2]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Block for circuit creation." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "from functools import reduce\n", + "def linear_feature_map(x: np.ndarray) -> float:\n", + " coeff = x[0] if len(x) == 1 else reduce(lambda m, n: m*n, x)\n", + " return coeff\n", + "feature_map = ZZFeatureMap(feature_dimension=feature_dim, reps=2, data_map_func=linear_feature_map, entanglement='linear')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run QSVM" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "seed = 1000\n", + "qsvm = QSVM(feature_map, training_input, test_input, datapoints[0])\n", + "backend = provider.get_backend('ibmq_qasm_simulator')\n", + "#backend = provider.get_backend('ibmq_16_melbourne')\n", + "quantum_instance = QuantumInstance(backend, shots=1024, seed_simulator=seed, seed_transpiler=seed)\n", + "#quantum_instance = QuantumInstance(backend, shots=1024)\n", + "result = qsvm.run(quantum_instance)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The results for the given test set and datapoints are shown in the following:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Testing success ratio: 0.525\n", + "Prediction from datapoints set:\n", + " success rate: 51.55555555555556%\n", + " F1 score: 0.441025641025641\n", + " Accuracy: 0.5155555555555555\n" + ] + }, + { + "data": { + "text/plain": [ + "<matplotlib.image.AxesImage at 0x1ab97a4b5b0>" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 360x360 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "print(f'Testing success ratio: {result[\"testing_accuracy\"]}')\n", + "print('Prediction from datapoints set:')\n", + "#print(f' ground truth: {map_label_to_class_name(datapoints[1], qsvm.label_to_class)}')\n", + "#print(f' prediction: {result[\"predicted_classes\"]}')\n", + "predicted_labels = result[\"predicted_labels\"]\n", + "print(f' success rate: {100*np.count_nonzero(predicted_labels == datapoints[1])/len(predicted_labels)}%')\n", + "print(f' F1 score: {f1_score(datapoints[1], result[\"predicted_labels\"])}')\n", + "print(f' Accuracy: {accuracy_score(datapoints[1], result[\"predicted_labels\"])}')\n", + "classification_map=np.reshape(result[\"predicted_labels\"],(N,N))\n", + "plt.imshow(classification_map, cmap=cmap)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 360x360 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "kernel_matrix = result['kernel_matrix_training']\n", + "plt.imshow(np.asmatrix(kernel_matrix),interpolation='nearest',origin='upper',cmap='bone_r');" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<h3>Version Information</h3><table><tr><th>Qiskit Software</th><th>Version</th></tr><tr><td>Qiskit</td><td>0.26.2</td></tr><tr><td>Terra</td><td>0.17.4</td></tr><tr><td>Aer</td><td>0.8.2</td></tr><tr><td>Ignis</td><td>0.6.0</td></tr><tr><td>Aqua</td><td>0.9.1</td></tr><tr><td>IBM Q Provider</td><td>0.13.1</td></tr><tr><th>System information</th></tr><tr><td>Python</td><td>3.8.3 (default, Jul 2 2020, 17:30:36) [MSC v.1916 64 bit (AMD64)]</td></tr><tr><td>OS</td><td>Windows</td></tr><tr><td>CPUs</td><td>2</td></tr><tr><td>Memory (Gb)</td><td>7.881378173828125</td></tr><tr><td colspan='2'>Wed Jul 14 13:47:38 2021 W. Europe Daylight Time</td></tr></table>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<div style='width: 100%; background-color:#d5d9e0;padding-left: 10px; padding-bottom: 10px; padding-right: 10px; padding-top: 5px'><h3>This code is a part of Qiskit</h3><p>© Copyright IBM 2017, 2021.</p><p>This code is licensed under the Apache License, Version 2.0. You may<br>obtain a copy of this license in the LICENSE.txt file in the root directory<br> of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.<p>Any modifications or derivative works of this code must retain this<br>copyright notice, and modified files need to carry a notice indicating<br>that they have been altered from the originals.</p></div>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import qiskit.tools.jupyter\n", + "%qiskit_version_table\n", + "%qiskit_copyright" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} -- GitLab