{ "cells": [ { "cell_type": "markdown", "id": "opened-florist", "metadata": {}, "source": [ "# Pegasos Quantum Support Vector Classifier\n", "\n", "There's another SVM based algorithm that benefits from the quantum kernel method. Here, we introduce an implementation of a another classification algorithm, which is an alternative version to the `QSVC` available in Qiskit Machine Learning and shown in the [\"Quantum Kernel Machine Learning\"](./03_quantum_kernel.ipynb) tutorial. This classification algorithm implements the Pegasos algorithm from the paper \"Pegasos: Primal Estimated sub-GrAdient SOlver for SVM\" by Shalev-Shwartz et al., see: https://home.ttic.edu/~nati/Publications/PegasosMPB.pdf.\n", "\n", "This algorithm is an alternative to the dual optimization from the `scikit-learn` package, benefits from the kernel trick, and yields a training complexity that is independent of the size of the training set. Thus, the `PegasosQSVC` is expected to train faster than QSVC for sufficiently large training sets.\n", "\n", "The algorithm can be used as direct replacement of `QSVC` with some hyper-parameterization." ] }, { "cell_type": "markdown", "id": "thirty-painting", "metadata": {}, "source": [ "Let's generate some data:" ] }, { "cell_type": "code", "execution_count": 1, "id": "impressed-laser", "metadata": {}, "outputs": [], "source": [ "from sklearn.datasets import make_blobs\n", "\n", "# example dataset\n", "features, labels = make_blobs(n_samples=20, n_features=2, centers=2, random_state=3, shuffle=True)" ] }, { "cell_type": "markdown", "id": "moderate-yugoslavia", "metadata": {}, "source": [ "We pre-process the data to ensure compatibility with the rotation encoding and split it into the training and test datasets." ] }, { "cell_type": "code", "execution_count": 2, "id": "adolescent-composer", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "\n", "from sklearn.model_selection import train_test_split\n", "from sklearn.preprocessing import MinMaxScaler\n", "\n", "features = MinMaxScaler(feature_range=(0, np.pi)).fit_transform(features)\n", "\n", "train_features, test_features, train_labels, test_labels = train_test_split(\n", " features, labels, train_size=15, shuffle=False\n", ")" ] }, { "cell_type": "markdown", "id": "central-poverty", "metadata": {}, "source": [ "We have two features in the dataset, so we set a number of qubits to the number of features in the dataset.\n", "\n", "Then we set $\\tau$ to the number of steps performed during the training procedure. Please note that, there is no early stopping criterion in the algorithm. The algorithm iterates over all $\\tau$ steps.\n", "\n", "And the last one is the hyperparameter $C$. This is a positive regularization parameter. The strength of the regularization is inversely proportional to $C$. Smaller $C$ induce smaller weights which generally helps preventing overfitting. However, due to the nature of this algorithm, some of the computation steps become trivial for larger $C$. Thus, larger $C$ improve the performance of the algorithm drastically. If the data is linearly separable in feature space, $C$ should be chosen to be large. If the separation is not perfect, $C$ should be chosen smaller to prevent overfitting." ] }, { "cell_type": "code", "execution_count": 3, "id": "dying-dispatch", "metadata": {}, "outputs": [], "source": [ "# number of qubits is equal to the number of features\n", "num_qubits = 2\n", "\n", "# number of steps performed during the training procedure\n", "tau = 100\n", "\n", "# regularization parameter\n", "C = 1000" ] }, { "cell_type": "markdown", "id": "improving-wilderness", "metadata": {}, "source": [ "The algorithm will run using:\n", "\n", "- The default fidelity instantiated in `FidelityQuantumKernel`\n", "- A quantum kernel created from `ZFeatureMap`" ] }, { "cell_type": "code", "execution_count": 4, "id": "automated-allergy", "metadata": {}, "outputs": [], "source": [ "from qiskit import BasicAer\n", "from qiskit.circuit.library import ZFeatureMap\n", "from qiskit_algorithms.utils import algorithm_globals\n", "\n", "from qiskit_machine_learning.kernels import FidelityQuantumKernel\n", "\n", "algorithm_globals.random_seed = 12345\n", "\n", "feature_map = ZFeatureMap(feature_dimension=num_qubits, reps=1)\n", "\n", "qkernel = FidelityQuantumKernel(feature_map=feature_map)" ] }, { "cell_type": "markdown", "id": "attractive-stationery", "metadata": {}, "source": [ "The implementation `PegasosQSVC` is compatible with the `scikit-learn` interfaces and has a pretty standard way of training a model. In the constructor we pass parameters of the algorithm, in this case there are a regularization hyper-parameter $C$ and a number of steps.\n", "\n", "Then we pass training features and labels to the `fit` method, which trains a models and returns a fitted classifier.\n", "\n", "Afterwards, we score our model using test features and labels." ] }, { "cell_type": "code", "execution_count": 5, "id": "representative-thumb", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "PegasosQSVC classification test score: 1.0\n" ] } ], "source": [ "from qiskit_machine_learning.algorithms import PegasosQSVC\n", "\n", "pegasos_qsvc = PegasosQSVC(quantum_kernel=qkernel, C=C, num_steps=tau)\n", "\n", "# training\n", "pegasos_qsvc.fit(train_features, train_labels)\n", "\n", "# testing\n", "pegasos_score = pegasos_qsvc.score(test_features, test_labels)\n", "print(f\"PegasosQSVC classification test score: {pegasos_score}\")" ] }, { "cell_type": "markdown", "id": "sustainable-empire", "metadata": {}, "source": [ "For visualization purposes we create a mesh grid of a predefined step that spans our minimum and maximum values we applied in MinMaxScaler. We also add some margin to the grid for better representation of the training and test samples." ] }, { "cell_type": "code", "execution_count": 6, "id": "judicial-pottery", "metadata": {}, "outputs": [], "source": [ "grid_step = 0.2\n", "margin = 0.2\n", "grid_x, grid_y = np.meshgrid(\n", " np.arange(-margin, np.pi + margin, grid_step), np.arange(-margin, np.pi + margin, grid_step)\n", ")" ] }, { "cell_type": "markdown", "id": "marine-constitution", "metadata": {}, "source": [ "We convert the grid to the shape compatible with the model, the shape should be `(n_samples, n_features)`.\n", "Then for each grid point we predict a label. In our case predicted labels will be used for coloring the grid." ] }, { "cell_type": "code", "execution_count": 7, "id": "competitive-outdoors", "metadata": {}, "outputs": [], "source": [ "meshgrid_features = np.column_stack((grid_x.ravel(), grid_y.ravel()))\n", "meshgrid_colors = pegasos_qsvc.predict(meshgrid_features)" ] }, { "cell_type": "markdown", "id": "former-constraint", "metadata": {}, "source": [ "Finally, we plot our grid according to the labels/colors we obtained from the model. We also plot training and test samples." ] }, { "cell_type": "code", "execution_count": 8, "id": "monetary-knife", "metadata": { "tags": [ "nbsphinx-thumbnail" ] }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "\n", "plt.figure(figsize=(5, 5))\n", "meshgrid_colors = meshgrid_colors.reshape(grid_x.shape)\n", "plt.pcolormesh(grid_x, grid_y, meshgrid_colors, cmap=\"RdBu\", shading=\"auto\")\n", "\n", "plt.scatter(\n", " train_features[:, 0][train_labels == 0],\n", " train_features[:, 1][train_labels == 0],\n", " marker=\"s\",\n", " facecolors=\"w\",\n", " edgecolors=\"r\",\n", " label=\"A train\",\n", ")\n", "plt.scatter(\n", " train_features[:, 0][train_labels == 1],\n", " train_features[:, 1][train_labels == 1],\n", " marker=\"o\",\n", " facecolors=\"w\",\n", " edgecolors=\"b\",\n", " label=\"B train\",\n", ")\n", "\n", "plt.scatter(\n", " test_features[:, 0][test_labels == 0],\n", " test_features[:, 1][test_labels == 0],\n", " marker=\"s\",\n", " facecolors=\"r\",\n", " edgecolors=\"r\",\n", " label=\"A test\",\n", ")\n", "plt.scatter(\n", " test_features[:, 0][test_labels == 1],\n", " test_features[:, 1][test_labels == 1],\n", " marker=\"o\",\n", " facecolors=\"b\",\n", " edgecolors=\"b\",\n", " label=\"B test\",\n", ")\n", "\n", "plt.legend(bbox_to_anchor=(1.05, 1), loc=\"upper left\", borderaxespad=0.0)\n", "plt.title(\"Pegasos Classification\")\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 9, "id": "imperial-promise", "metadata": {}, "outputs": [ { "data": { "text/html": [ "

Version Information

Qiskit SoftwareVersion
qiskit-terra0.22.0
qiskit-aer0.11.0
qiskit-ignis0.7.0
qiskit0.33.0
qiskit-machine-learning0.5.0
System information
Python version3.7.9
Python compilerMSC v.1916 64 bit (AMD64)
Python builddefault, Aug 31 2020 17:10:11
OSWindows
CPUs4
Memory (Gb)31.837730407714844
Thu Oct 13 10:42:49 2022 GMT Daylight Time
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "

This code is a part of Qiskit

© Copyright IBM 2017, 2022.

This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.

" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import qiskit.tools.jupyter\n", "\n", "%qiskit_version_table\n", "%qiskit_copyright" ] } ], "metadata": { "celltoolbar": "Tags", "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" } }, "nbformat": 4, "nbformat_minor": 5 }