Italian
Linguaggi
English
Bengali
French
Hindi
Italian
Japanese
Korean
Malayalam
Russian
Spanish
Tamil
Turkish
Vietnamese
Shortcuts

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.

[3]:
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.circuit.library import ZZFeatureMap
from qiskit.utils import QuantumInstance, algorithm_globals
from qiskit_machine_learning.algorithms import QSVC
from qiskit_machine_learning.kernels import QuantumKernel
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()
../_images/tutorials_03_quantum_kernel_3_0.png

Con i nostri dataset di train e test pronti, creiamo la classe QuantumKernel per calcolare la matrice di kernel usando la ZZFeatureMap, ed il qasm_simulator di BasicAer, utilizzando 1024 shots.

[3]:
adhoc_feature_map = ZZFeatureMap(feature_dimension=adhoc_dimension, reps=2, entanglement="linear")

adhoc_backend = QuantumInstance(
    BasicAer.get_backend("qasm_simulator"), shots=1024, seed_simulator=seed, seed_transpiler=seed
)

adhoc_kernel = QuantumKernel(feature_map=adhoc_feature_map, quantum_instance=adhoc_backend)

L’algoritmo svc di scikit-learn ci permette di definire un custom kernel in due modi: fornendo il kernel come una funzione richiamabile o calcolando in anticipo la matrice di kernel. Possiamo utilizzare indistintamente uno dei due metodi anche quando usiamo la classe QuantumKernel di 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}")
../_images/tutorials_03_quantum_kernel_9_0.png
Precomputed kernel classification test score: 1.0

qiskit contiene anche la classe qsvc che estende la classe sklearn svc e che può essere utilizzata come segue:

[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.

Creeremo il dataset con una separazione maggiore tra le due classi, e non avremo bisogno di un campione di test, in un quanto il clustering è un algoritmo di machine learning non supervisionato.

[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()
../_images/tutorials_03_quantum_kernel_13_0.png

Ancora una volta inizializziamo la classe QuantumKernel per calcolare una matrice di kernel usando una ZZFeatureMap, ed il qasm_simulator di BasicAer con 1024 shots.

[8]:
adhoc_feature_map = ZZFeatureMap(feature_dimension=adhoc_dimension, reps=2, entanglement="linear")

adhoc_backend = QuantumInstance(
    BasicAer.get_backend("qasm_simulator"), shots=1024, seed_simulator=seed, seed_transpiler=seed
)

adhoc_kernel = QuantumKernel(feature_map=adhoc_feature_map, quantum_instance=adhoc_backend)

L’algoritmo di clustering spectral di scikit-learn ci permette di definire un [custom kernel] in due modi: fornendo il kernel come una funzione richiamabile, o calcolando in anticipo la matrice di kernel. Quando utilizziamo la classe QuantumKernel in Qiskit, possiamo utilizzare solo il secondo.

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}")
../_images/tutorials_03_quantum_kernel_17_0.png
Clustering score: 0.7287008798015754

scikit-learn fornisce anche altri algoritmi che possono utilizzare una matrice di kernel pre-calcolata, eccone alcuni:

[1]:
import qiskit.tools.jupyter

%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit SoftwareVersion
qiskit-terra0.19.0
qiskit-aer0.8.2
qiskit-ignis0.6.0
qiskit-aqua0.9.2
qiskit0.27.0
qiskit-machine-learning0.3.0
System information
Python3.7.9 (default, Aug 31 2020, 17:10:11) [MSC v.1916 64 bit (AMD64)]
OSWindows
CPUs4
Memory (Gb)31.837730407714844
Fri Dec 03 15:08:20 2021 GMT Standard Time

This code is a part of Qiskit

© Copyright IBM 2017, 2021.

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.