Nota
Questa pagina è stata generata da docs/tutorials/03_quantum_kernel.ipynb.
Quantum Kernel Machine Learning¶
L’obiettivo generale del machine learning è quello di trovare e studiare pattern nei dati. Per molti dataset, i dati sono meglio interpretati in uno spazio delle feature di dimensione più alta rispetto a quello di partenza, raggiunto attraverso l’uso di una funzione kernel: \(k(\vec{x}_i, \vec{x}_j) = \langle f(\vec{x}_i), f(\vec{x}_j) \rangle\), dove \(k\) è la funzione kernel, \(\vec{x}_i, \vec{x}_j\) sono input a \(n\) dimensioni, \(f\) è una mappa da uno spazio \(n\)-dimensionale ad uno spazio \(m\)-dimensionale, e \(\langle a, \rangle\) indica il prodotto scalare. Quando si considerano dati finiti, una funzione kernel può essere rappresentata come una matrice: \(K_{ij} = k(\vec{x}_i,\vec{x}_j)\).
Nel quantum kernel machine learning, si utilizza una feature map quantistica \(\phi(\vec{x})\) per mappare un vettore classico \(\vec{x}\) in uno spazio di Hilbert quantistico, \(| \phi(\vec{x})\rangle \langle \phi(\vec{x})|\), tale che \(K_{ij} = \left| \langle \phi^\dagger(\vec{x}_j)| \phi(\vec{x}_i) \rangle \right|^{2}\). Per maggiori dettagli, si può fare riferimento a Supervised learning with quantum enhanced feature spaces .
In questo notebook usiamo qiskit
per calcolare una matrice di kernel usando una feature map quantistica, poi utilizziamo questa matrice di kernel negli algoritmi di classificazione e di clustering in scikit-learn
.
[1]:
import matplotlib.pyplot as plt
import numpy as np
from sklearn.svm import SVC
from sklearn.cluster import SpectralClustering
from sklearn.metrics import normalized_mutual_info_score
from qiskit import BasicAer
from qiskit.algorithms.state_fidelities import ComputeUncompute
from qiskit.circuit.library import ZZFeatureMap
from qiskit.primitives import Sampler
from qiskit.utils import algorithm_globals
from qiskit_machine_learning.algorithms import QSVC
from qiskit_machine_learning.kernels import FidelityQuantumKernel
from qiskit_machine_learning.datasets import ad_hoc_data
seed = 12345
algorithm_globals.random_seed = seed
Classificazione¶
Seguendo Supervised learning with quantum enhanced feature spaces, nel nostro esempio di classificazione, utilizzeremo un dataset ad hoc e, come algoritmo di classificazione, useremo la support vector machine (svc
) di scikit-learn
.
[2]:
adhoc_dimension = 2
train_features, train_labels, test_features, test_labels, adhoc_total = ad_hoc_data(
training_size=20,
test_size=5,
n=adhoc_dimension,
gap=0.3,
plot_data=False,
one_hot=False,
include_sample_total=True,
)
plt.figure(figsize=(5, 5))
plt.ylim(0, 2 * np.pi)
plt.xlim(0, 2 * np.pi)
plt.imshow(
np.asmatrix(adhoc_total).T,
interpolation="nearest",
origin="lower",
cmap="RdBu",
extent=[0, 2 * np.pi, 0, 2 * np.pi],
)
plt.scatter(
train_features[np.where(train_labels[:] == 0), 0],
train_features[np.where(train_labels[:] == 0), 1],
marker="s",
facecolors="w",
edgecolors="b",
label="A train",
)
plt.scatter(
train_features[np.where(train_labels[:] == 1), 0],
train_features[np.where(train_labels[:] == 1), 1],
marker="o",
facecolors="w",
edgecolors="r",
label="B train",
)
plt.scatter(
test_features[np.where(test_labels[:] == 0), 0],
test_features[np.where(test_labels[:] == 0), 1],
marker="s",
facecolors="b",
edgecolors="w",
label="A test",
)
plt.scatter(
test_features[np.where(test_labels[:] == 1), 0],
test_features[np.where(test_labels[:] == 1), 1],
marker="o",
facecolors="r",
edgecolors="w",
label="B test",
)
plt.legend(bbox_to_anchor=(1.05, 1), loc="upper left", borderaxespad=0.0)
plt.title("Ad hoc dataset for classification")
plt.show()

With our training and testing datasets ready, we set up the FidelityQuantumKernel
class to calculate a kernel matrix using the ZZFeatureMap. We use the reference implementation of the Sampler
primitive and the ComputeUncompute
fidelity that computes overlaps between states. These are the default values and if you don’t pass a Sampler
or Fidelity
instance, the same objects will be created
automatically for you.
[3]:
adhoc_feature_map = ZZFeatureMap(feature_dimension=adhoc_dimension, reps=2, entanglement="linear")
sampler = Sampler()
fidelity = ComputeUncompute(sampler=sampler)
adhoc_kernel = FidelityQuantumKernel(fidelity=fidelity, feature_map=adhoc_feature_map)
The scikit-learn
SVC
algorithm allows us to define a custom kernel in two ways: by providing the kernel as a callable function or by precomputing the kernel matrix. We can do either of these using the FidelityQuantumKernel
class in qiskit
.
Il seguente codice fornisce il kernel come funzione richiamabile:
[4]:
adhoc_svc = SVC(kernel=adhoc_kernel.evaluate)
adhoc_svc.fit(train_features, train_labels)
adhoc_score = adhoc_svc.score(test_features, test_labels)
print(f"Callable kernel classification test score: {adhoc_score}")
Callable kernel classification test score: 1.0
Il seguente codice precalcola e mostra le matrici kernel realative ai dati di training e di test prima di fornirle all’algoritmo svc
di scikit-learn
:
[5]:
adhoc_matrix_train = adhoc_kernel.evaluate(x_vec=train_features)
adhoc_matrix_test = adhoc_kernel.evaluate(x_vec=test_features, y_vec=train_features)
fig, axs = plt.subplots(1, 2, figsize=(10, 5))
axs[0].imshow(
np.asmatrix(adhoc_matrix_train), interpolation="nearest", origin="upper", cmap="Blues"
)
axs[0].set_title("Ad hoc training kernel matrix")
axs[1].imshow(np.asmatrix(adhoc_matrix_test), interpolation="nearest", origin="upper", cmap="Reds")
axs[1].set_title("Ad hoc testing kernel matrix")
plt.show()
adhoc_svc = SVC(kernel="precomputed")
adhoc_svc.fit(adhoc_matrix_train, train_labels)
adhoc_score = adhoc_svc.score(adhoc_matrix_test, test_labels)
print(f"Precomputed kernel classification test score: {adhoc_score}")

Precomputed kernel classification test score: 1.0
Qiskit Machine Learning also contains the QSVC
class that extends the SVC
class from scikit-learn, that can be used as follows:
[6]:
qsvc = QSVC(quantum_kernel=adhoc_kernel)
qsvc.fit(train_features, train_labels)
qsvc_score = qsvc.score(test_features, test_labels)
print(f"QSVC classification test score: {qsvc_score}")
QSVC classification test score: 1.0
Clustering¶
Seguendo Supervised learning with quantum enhanced feature spaces, nel nostro esempio di clustering, utilizzeremo un dataset ad hoc e, l’algoritmo di clustering spectral
di scikit-learn
.
We will regenerate the dataset with a larger gap between the two classes, and as clustering is an unsupervised machine learning task, we don’t need a test sample.
[7]:
adhoc_dimension = 2
train_features, train_labels, test_features, test_labels, adhoc_total = ad_hoc_data(
training_size=25,
test_size=0,
n=adhoc_dimension,
gap=0.6,
plot_data=False,
one_hot=False,
include_sample_total=True,
)
plt.figure(figsize=(5, 5))
plt.ylim(0, 2 * np.pi)
plt.xlim(0, 2 * np.pi)
plt.imshow(
np.asmatrix(adhoc_total).T,
interpolation="nearest",
origin="lower",
cmap="RdBu",
extent=[0, 2 * np.pi, 0, 2 * np.pi],
)
plt.scatter(
train_features[np.where(train_labels[:] == 0), 0],
train_features[np.where(train_labels[:] == 0), 1],
marker="s",
facecolors="w",
edgecolors="b",
label="A",
)
plt.scatter(
train_features[np.where(train_labels[:] == 1), 0],
train_features[np.where(train_labels[:] == 1), 1],
marker="o",
facecolors="w",
edgecolors="r",
label="B",
)
plt.legend(bbox_to_anchor=(1.05, 1), loc="upper left", borderaxespad=0.0)
plt.title("Ad hoc dataset for clustering")
plt.show()

We again set up the FidelityQuantumKernel
class to calculate a kernel matrix using the ZZFeatureMap, and the default values this time.
[8]:
adhoc_feature_map = ZZFeatureMap(feature_dimension=adhoc_dimension, reps=2, entanglement="linear")
adhoc_kernel = FidelityQuantumKernel(feature_map=adhoc_feature_map)
The scikit-learn spectral clustering algorithm allows us to define a custom kernel in two ways: by providing the kernel as a callable function or by precomputing the kernel matrix. Using the FidelityQuantumKernel
class in Qiskit Machine Learning, we can only use the latter.
Il seguente codice pre-calcola e mostra le matrici di kernel prima di fornirle all’algoritmo di clustering spectral di scikit-learning, e prima di valutare i label utilizzando l’informazione reciproca normalizzata, dato che conosciamo a priori i label delle classi.
[9]:
adhoc_matrix = adhoc_kernel.evaluate(x_vec=train_features)
plt.figure(figsize=(5, 5))
plt.imshow(np.asmatrix(adhoc_matrix), interpolation="nearest", origin="upper", cmap="Greens")
plt.title("Ad hoc clustering kernel matrix")
plt.show()
adhoc_spectral = SpectralClustering(2, affinity="precomputed")
cluster_labels = adhoc_spectral.fit_predict(adhoc_matrix)
cluster_score = normalized_mutual_info_score(cluster_labels, train_labels)
print(f"Clustering score: {cluster_score}")

Clustering score: 0.7287008798015754
scikit-learn
fornisce anche altri algoritmi che possono utilizzare una matrice di kernel pre-calcolata, eccone alcuni:
[10]:
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
Version Information
Qiskit Software | Version |
---|---|
qiskit-terra | 0.22.0 |
qiskit-aer | 0.11.0 |
qiskit-ignis | 0.7.0 |
qiskit | 0.33.0 |
qiskit-machine-learning | 0.5.0 |
System information | |
Python version | 3.7.9 |
Python compiler | MSC v.1916 64 bit (AMD64) |
Python build | default, Aug 31 2020 17:10:11 |
OS | Windows |
CPUs | 4 |
Memory (Gb) | 31.837730407714844 |
Mon Oct 10 12:01:53 2022 GMT Daylight Time |
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.