{ "cells": [ { "cell_type": "markdown", "id": "38df9aa0", "metadata": {}, "source": [ "# Quantum Kernel Training for Machine Learning Applications\n", "\n", "In this tutorial, we will train a quantum kernel on a labeled dataset for a machine learning application. To illustrate the basic steps, we will use Quantum Kernel Alignment (QKA) for a binary classification task. QKA is a technique that iteratively adapts a parametrized quantum kernel to a dataset while converging to the maximum SVM margin. More information about QKA can be found in the preprint, [\"Covariant quantum kernels for data with group structure.\"](https://arxiv.org/abs/2105.03406)\n", "\n", "\n", "The entry point to training a quantum kernel is the `QuantumKernelTrainer` class. The basic steps are:\n", "\n", "1. Prepare the dataset\n", "2. Define the quantum feature map\n", "3. Set up an instance of `TrainableKernel` and `QuantumKernelTrainer` objects\n", "4. Use the `QuantumKernelTrainer.fit` method to train the kernel parameters on the dataset\n", "5. Pass the trained quantum kernel to a machine learning model" ] }, { "cell_type": "markdown", "id": "ed6aafa9", "metadata": {}, "source": [ "### Import Local, External, and Qiskit Packages and define a callback class for our optimizer" ] }, { "cell_type": "code", "execution_count": 1, "id": "1a646351", "metadata": {}, "outputs": [], "source": [ "# External imports\n", "from pylab import cm\n", "from sklearn import metrics\n", "import numpy as np\n", "import matplotlib\n", "import matplotlib.pyplot as plt\n", "\n", "# Qiskit imports\n", "from qiskit import QuantumCircuit\n", "from qiskit.circuit import ParameterVector\n", "from qiskit.visualization import circuit_drawer\n", "from qiskit.circuit.library import ZZFeatureMap\n", "from qiskit_algorithms.optimizers import SPSA\n", "from qiskit_machine_learning.kernels import TrainableFidelityQuantumKernel\n", "from qiskit_machine_learning.kernels.algorithms import QuantumKernelTrainer\n", "from qiskit_machine_learning.algorithms import QSVC\n", "from qiskit_machine_learning.datasets import ad_hoc_data\n", "\n", "\n", "class QKTCallback:\n", " \"\"\"Callback wrapper class.\"\"\"\n", "\n", " def __init__(self) -> None:\n", " self._data = [[] for i in range(5)]\n", "\n", " def callback(self, x0, x1=None, x2=None, x3=None, x4=None):\n", " \"\"\"\n", " Args:\n", " x0: number of function evaluations\n", " x1: the parameters\n", " x2: the function value\n", " x3: the stepsize\n", " x4: whether the step was accepted\n", " \"\"\"\n", " self._data[0].append(x0)\n", " self._data[1].append(x1)\n", " self._data[2].append(x2)\n", " self._data[3].append(x3)\n", " self._data[4].append(x4)\n", "\n", " def get_callback_data(self):\n", " return self._data\n", "\n", " def clear_callback_data(self):\n", " self._data = [[] for i in range(5)]" ] }, { "cell_type": "markdown", "id": "39535c04", "metadata": {}, "source": [ "### Prepare the Dataset\n", "\n", "In this guide, we will use Qiskit Machine Learning's `ad_hoc.py` dataset to demonstrate the kernel training process. See the documentation [here](https://qiskit.org/ecosystem/machine-learning/stubs/qiskit_machine_learning.datasets.ad_hoc_data.html)." ] }, { "cell_type": "code", "execution_count": 2, "id": "2311cff1", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "adhoc_dimension = 2\n", "X_train, y_train, X_test, y_test, adhoc_total = ad_hoc_data(\n", " training_size=20,\n", " test_size=5,\n", " n=adhoc_dimension,\n", " gap=0.3,\n", " plot_data=False,\n", " one_hot=False,\n", " include_sample_total=True,\n", ")\n", "\n", "plt.figure(figsize=(5, 5))\n", "plt.ylim(0, 2 * np.pi)\n", "plt.xlim(0, 2 * np.pi)\n", "plt.imshow(\n", " np.asmatrix(adhoc_total).T,\n", " interpolation=\"nearest\",\n", " origin=\"lower\",\n", " cmap=\"RdBu\",\n", " extent=[0, 2 * np.pi, 0, 2 * np.pi],\n", ")\n", "\n", "plt.scatter(\n", " X_train[np.where(y_train[:] == 0), 0],\n", " X_train[np.where(y_train[:] == 0), 1],\n", " marker=\"s\",\n", " facecolors=\"w\",\n", " edgecolors=\"b\",\n", " label=\"A train\",\n", ")\n", "plt.scatter(\n", " X_train[np.where(y_train[:] == 1), 0],\n", " X_train[np.where(y_train[:] == 1), 1],\n", " marker=\"o\",\n", " facecolors=\"w\",\n", " edgecolors=\"r\",\n", " label=\"B train\",\n", ")\n", "plt.scatter(\n", " X_test[np.where(y_test[:] == 0), 0],\n", " X_test[np.where(y_test[:] == 0), 1],\n", " marker=\"s\",\n", " facecolors=\"b\",\n", " edgecolors=\"w\",\n", " label=\"A test\",\n", ")\n", "plt.scatter(\n", " X_test[np.where(y_test[:] == 1), 0],\n", " X_test[np.where(y_test[:] == 1), 1],\n", " marker=\"o\",\n", " facecolors=\"r\",\n", " edgecolors=\"w\",\n", " label=\"B test\",\n", ")\n", "\n", "plt.legend(bbox_to_anchor=(1.05, 1), loc=\"upper left\", borderaxespad=0.0)\n", "plt.title(\"Ad hoc dataset for classification\")\n", "\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "41a439be", "metadata": {}, "source": [ "### Define the Quantum Feature Map\n", "\n", "Next, we set up the quantum feature map, which encodes classical data into the quantum state space. Here, we use a `QuantumCircuit` to set up a trainable rotation layer and a `ZZFeatureMap` from `Qiskit` to represent the input data." ] }, { "cell_type": "code", "execution_count": 3, "id": "60b58ede", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " ┌──────────┐┌──────────────────────────┐\n", "q_0: ┤ Ry(θ[0]) ├┤0 ├\n", " ├──────────┤│ ZZFeatureMap(x[0],x[1]) │\n", "q_1: ┤ Ry(θ[0]) ├┤1 ├\n", " └──────────┘└──────────────────────────┘\n", "Trainable parameters: θ, ['θ[0]']\n" ] } ], "source": [ "# Create a rotational layer to train. We will rotate each qubit the same amount.\n", "training_params = ParameterVector(\"θ\", 1)\n", "fm0 = QuantumCircuit(2)\n", "fm0.ry(training_params[0], 0)\n", "fm0.ry(training_params[0], 1)\n", "\n", "# Use ZZFeatureMap to represent input data\n", "fm1 = ZZFeatureMap(2)\n", "\n", "# Create the feature map, composed of our two circuits\n", "fm = fm0.compose(fm1)\n", "\n", "print(circuit_drawer(fm))\n", "print(f\"Trainable parameters: {training_params}\")" ] }, { "cell_type": "markdown", "id": "54ae41ca", "metadata": {}, "source": [ "### Set Up the Quantum Kernel and Quantum Kernel Trainer\n", "\n", "To train the quantum kernel, we will use an instance of `TrainableFidelityQuantumKernel` (holds the feature map and its parameters) and `QuantumKernelTrainer` (manages the training process).\n", "\n", "We will train using the Quantum Kernel Alignment technique by selecting the kernel loss function, `SVCLoss`, as input to the `QuantumKernelTrainer`. Since this is a Qiskit-supported loss, we can use the string, `\"svc_loss\"`; however, note that default settings are used when passing the loss as a string. For custom settings, instantiate explicitly with the desired options, and pass the `KernelLoss` object to the `QuantumKernelTrainer`.\n", "\n", "We will select SPSA as the optimizer and initialize the trainable parameter with the `initial_point` argument. Note: The length of the list passed as the `initial_point` argument must equal the number of trainable parameters in the feature map." ] }, { "cell_type": "code", "execution_count": 4, "id": "a190efef", "metadata": {}, "outputs": [], "source": [ "# Instantiate quantum kernel\n", "quant_kernel = TrainableFidelityQuantumKernel(feature_map=fm, training_parameters=training_params)\n", "\n", "# Set up the optimizer\n", "cb_qkt = QKTCallback()\n", "spsa_opt = SPSA(maxiter=10, callback=cb_qkt.callback, learning_rate=0.05, perturbation=0.05)\n", "\n", "# Instantiate a quantum kernel trainer.\n", "qkt = QuantumKernelTrainer(\n", " quantum_kernel=quant_kernel, loss=\"svc_loss\", optimizer=spsa_opt, initial_point=[np.pi / 2]\n", ")" ] }, { "cell_type": "markdown", "id": "b6f4fd48", "metadata": {}, "source": [ "### Train the Quantum Kernel\n", "\n", "To train the quantum kernel on the dataset (samples and labels), we call the `fit` method of `QuantumKernelTrainer`.\n", "\n", "The output of `QuantumKernelTrainer.fit` is a `QuantumKernelTrainerResult` object. The results object contains the following class fields:\n", "\n", " - `optimal_parameters`: A dictionary containing {parameter: optimal value} pairs\n", " - `optimal_point`: The optimal parameter value found in training\n", " - `optimal_value`: The value of the loss function at the optimal point\n", " - `optimizer_evals`: The number of evaluations performed by the optimizer\n", " - `optimizer_time`: The amount of time taken to perform optimization\n", " - `quantum_kernel`: A `TrainableKernel` object with optimal values bound to the feature map" ] }, { "cell_type": "code", "execution_count": 5, "id": "9d26212c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{ 'optimal_circuit': None,\n", " 'optimal_parameters': {ParameterVectorElement(θ[0]): 2.4745458584261386},\n", " 'optimal_point': array([2.47454586]),\n", " 'optimal_value': 7.399057680986741,\n", " 'optimizer_evals': 30,\n", " 'optimizer_result': None,\n", " 'optimizer_time': None,\n", " 'quantum_kernel': }\n" ] } ], "source": [ "# Train the kernel using QKT directly\n", "qka_results = qkt.fit(X_train, y_train)\n", "optimized_kernel = qka_results.quantum_kernel\n", "print(qka_results)" ] }, { "cell_type": "markdown", "id": "5455be3c", "metadata": {}, "source": [ "### Fit and Test the Model\n", "\n", "We can pass the trained quantum kernel to a machine learning model, then fit the model and test on new data. Here, we will use Qiskit Machine Learning's `QSVC` for classification." ] }, { "cell_type": "code", "execution_count": 6, "id": "e716655f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "accuracy test: 0.9\n" ] } ], "source": [ "# Use QSVC for classification\n", "qsvc = QSVC(quantum_kernel=optimized_kernel)\n", "\n", "# Fit the QSVC\n", "qsvc.fit(X_train, y_train)\n", "\n", "# Predict the labels\n", "labels_test = qsvc.predict(X_test)\n", "\n", "# Evalaute the test accuracy\n", "accuracy_test = metrics.balanced_accuracy_score(y_true=y_test, y_pred=labels_test)\n", "print(f\"accuracy test: {accuracy_test}\")" ] }, { "cell_type": "markdown", "id": "9cd4cbf2", "metadata": {}, "source": [ "### Visualize the Kernel Training Process\n", "\n", "From the callback data, we can plot how the loss evolves during the training process. We see it converges rapidly and reaches high test accuracy on this dataset with our choice of inputs.\n", "\n", "We can also display the final kernel matrix, which is a measure of similarity between the training samples." ] }, { "cell_type": "code", "execution_count": 7, "id": "0cb85c46", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_data = cb_qkt.get_callback_data() # callback data\n", "K = optimized_kernel.evaluate(X_train) # kernel matrix evaluated on the training samples\n", "\n", "plt.rcParams[\"font.size\"] = 20\n", "fig, ax = plt.subplots(1, 2, figsize=(14, 5))\n", "ax[0].plot([i + 1 for i in range(len(plot_data[0]))], np.array(plot_data[2]), c=\"k\", marker=\"o\")\n", "ax[0].set_xlabel(\"Iterations\")\n", "ax[0].set_ylabel(\"Loss\")\n", "ax[1].imshow(K, cmap=matplotlib.colormaps[\"bwr\"])\n", "fig.tight_layout()\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 8, "id": "aa6e50bc", "metadata": {}, "outputs": [ { "data": { "text/html": [ "

Version Information

Qiskit SoftwareVersion
qiskit-terra0.25.0
qiskit-aer0.13.0
qiskit-machine-learning0.7.0
System information
Python version3.8.13
Python compilerClang 12.0.0
Python builddefault, Oct 19 2022 17:54:22
OSDarwin
CPUs10
Memory (Gb)64.0
Mon May 29 12:50:08 2023 IST
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "

This code is a part of Qiskit

© Copyright IBM 2017, 2023.

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": { "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" }, "rise": { "height": "90%", "scroll": true, "start_slideshow_at": "beginning", "theme": "white", "transition": "zoom", "width": "90%" } }, "nbformat": 4, "nbformat_minor": 5 }