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

Nota

Esta página fue generada a partir de docs/tutorials/03_quantum_kernel.ipynb.

Machine Learning con Kernel Cuántico

La tarea general del machine learning es encontrar y estudiar patrones en los datos. Para muchos conjuntos de datos, los puntos de datos se comprenden mejor en un espacio de características de mayor dimensión, mediante el uso de una función de kernel: \(k(\vec{x}_i, \vec{x}_j) = \langle f(\vec{x}_i), f(\vec{x}_j) \rangle\) donde \(k\) es la función de kernel, \(\vec{x}_i, \vec{x}_j\) dimensionales, \(f\) es un mapa del espacio de dimensión \(n\) al espacio de dimensión \(m\) y \(\langle a,b \rangle\) denota el producto escalar. Cuando se consideran datos finitos, una función de kernel se puede representar como una matriz: \(K_{ij} = k(\vec{x}_i,\vec{x}_j)\).

En machine learning con kernel cuántico, se utiliza un mapa de características cuánticas \(\phi(\vec{x})\) para asignar un vector de características clásicas \(\vec{x}\) a un espacio cuántico de Hilbert, \(| \phi(\vec{x})\rangle \langle \phi(\vec{x})|\), tal que \(K_{ij} = \left| \langle \phi^\dagger(\vec{x}_j)| \phi(\vec{x}_i) \rangle \right|^{2}\). Consulta Supervised learning with quantum enhanced feature spaces para obtener más detalles.

En este cuaderno, usamos qiskit para calcular una matriz de kernel usando un mapa de características cuánticas, luego usamos esta matriz de kernel en algoritmos de clasificación y agrupamiento de 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.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

Clasificación

Para nuestro ejemplo de clasificación, usaremos el dataset ad hoc como se describe en Supervised learning with quantum enhanced feature spaces, y el algoritmo de clasificación support vector machine (svc) de 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.)
plt.title("Ad hoc dataset for classification")

plt.show()
../_images/tutorials_03_quantum_kernel_3_0.png

Con nuestros conjuntos de datos de entrenamiento y prueba listos, configuramos la clase QuantumKernel para calcular una matriz de kernel usando el ZZFeatureMap, y el qasm_simulator de ``BasicAer``usando 1024 iteraciones.

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

El algoritmo svc de scikit-learn nos permite definir un custom kernel de dos maneras: proporcionando el kernel como una función invocable o precomputando la matriz del kernel. Podemos hacer cualquiera de estos usando la clase QuantumKernel en qiskit.

El siguiente código da el kernel como una función invocable:

[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

El siguiente código precalcula y traza las matrices del kernel de entrenamiento y prueba antes de proporcionarlas al algoritmo svc de 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 también contiene la clase qsvc que extiende la clase ``sklearn svc`, que se puede usar de la siguiente manera:

[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

Agrupación (Clustering)

Para nuestro ejemplo de agrupamiento, usaremos nuevamente el dataset ad hoc como se describe en Supervised learning with quantum enhanced feature spaces, y el algoritmo de agrupación spectral de scikit-learn.

Regeneraremos el conjunto de datos con una brecha mayor entre las dos clases y, como la agrupación en clústeres es una tarea de machine learning no supervisada, no necesitamos una muestra de prueba.

[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.)
plt.title("Ad hoc dataset for clustering")

plt.show()
../_images/tutorials_03_quantum_kernel_13_0.png

Nuevamente configuramos la clase QuantumKernel para calcular una matriz de kernel usando el ZZFeatureMap, y el qasm_simulator de BasicAer usando 1024 iteraciones.

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

El algoritmo de agrupamiento espectral scikit-learn nos permite definir un [kernel personalizado] de dos formas: proporcionando el kernel como una función invocable o precomputando la matriz del kernel. Usando la clase QuantumKernel en qiskit, solo podemos usar este último.

El siguiente código precalcula y traza las matrices del kernel antes de proporcionarlo al algoritmo de agrupamiento espectral scikit-learn y puntuar las etiquetas utilizando información mutua normalizada, ya que conocemos las etiquetas de clase a priori.

[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 tiene otros algoritmos que pueden usar una matriz de kernel precalculada, aquí hay algunos:

[10]:
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit SoftwareVersion
QiskitNone
Terra0.17.0
Aer0.8.0
Ignis0.5.2
AquaNone
IBM Q ProviderNone
System information
Python3.7.9 (default, Aug 31 2020, 17:10:11) [MSC v.1916 64 bit (AMD64)]
OSWindows
CPUs4
Memory (Gb)31.837730407714844
Thu Apr 01 00:57:12 2021 GMT Daylight 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.