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

Note

Cette page a été générée à partir de docs/tutorials/03_quantum_kernel.ipynb.

Apprentissage automatique du noyau quantique

La tâche générale de l’apprentissage automatique est de trouver et d’étudier des modèles dans les données. Pour de nombreux jeux de données, les points de données sont mieux compris dans un espace de plus grande dimension par l’utilisation d’une fonction du noyau : \(k(\vec{x}_i, \vec{x}_j) = \langle f(\vec{x}_i), f(\vec{x}_j) \rangle\)\(k\) est la fonction du noyau, \(\vec{x}_i, \vec{x}_j\) sont \(n\) entrées dimensionnelles, \(f\) est une carte de \(n\)-dimension à \(m\)-dimension espace et \(\langle a, \rangle\) indique le produit à point. Lorsque l’on considère les données finies, une fonction du noyau peut être représentée par une matrice : \(K_{ij} = k(\vec{x}_i,\vec{x}_j)\).

Dans l’apprentissage de la machine quantique du noyau, une carte de fonction quantique \(\phi(\vec{x})\) est utilisée pour mapper un vecteur de trait classique \(\vec{x}\) à un espace Hilbert quantique, \(| \\phi(\vec{x})\rangle \langle \\phi(\vec{x})|\), tel que \(K_{ij} = \left| \langle \phi^\dagger(\vec{x}_j)| \\phi(\vec{x}_i) \rangle \right|^{2}\). Voir Apprentissage supervisé avec des espaces de fonctionnalités améliorés quantiques pour plus de détails.

Dans ce bloc-notes, nous utilisons ` ` qiskit ` ` pour calculer une matrice de noyau à l’aide d’une mappe de fonctions quantiques, puis utilisez cette matrice de noyau dans les algorithmes de classification et de classification 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

Classification

Pour notre exemple de classification, nous utiliserons * l’ensemble de données ad hoc * tel que décrit dans la section « Apprentissage supervisé avec les espaces de fonctions améliorés quantiques <https://arxiv.org/pdf/1804.11326.pdf>` __, et l’algorithme de type » science vectorielle  » <https://scikit-learn.org/stable/modules/svm.html>` __ classification (` ` svc ` `).

[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

Avec nos jeux de données de formation et de test prêt, nous avons configuré la classe ` ` QuantumKernel ` ` pour calculer la matrice du noyau à l’aide de la ` ` ZZFeatureMap <https://qiskit.org/documentation/stubs/qiskit.circuit.library.ZZFeatureMap.html>` __, et du ` ` BasicAer ` ` ` ` qasm_simulateur ` ` utilisant 1024 coups.

[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’algorithme ` ` scikit-learn ` ` ` ` svc ` ` nous permet de définir un noyau’personnalisé <https://scikit-learn.org/stable/modules/svm.html#custom-kernels>` __ de deux manières: en fournissant le noyau comme une fonction appelable ou en précalculant la matrice du noyau. Nous pouvons faire l’un ou l’autre de ces outils en utilisant la classe ` ` QuantumKernel ` ` dans ` ` qiskit ` `.

Le code suivant donne au noyau une fonction appelable:

[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

Le code suivant précalcule et trace la formation et teste les matrices du noyau avant de les fournir à l’algorithme ` ` scikit-learn ` ` ` svc ` `:

[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 ` ` contient également la classe ` ` qsvc ` ` qui étend la classe ` ` sklearn svc ` `, qui peut être utilisée comme suit:

[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

Pour notre exemple de classification, nous utiliserons ad hoc dataset tel que décrit dans la section « Apprentissage supervisé avec les espaces de fonctions améliorés quantiques <https://arxiv.org/pdf/1804.11326.pdf>` __, et le scikit-learn l’algorithme de regroupement spectral.

Nous allons régénérer le jeu de données avec un écart plus grand entre les deux classes, et comme le regroupement est une tâche d’apprentissage automatique non supervisée, nous n’avons pas besoin d’un échantillon de test.

[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

Avec nos jeux de données de formation et de test prêt, nous avons configuré la classe ` ` QuantumKernel ` ` pour calculer la matrice du noyau à l’aide de la ` ` ZZFeatureMap <https://qiskit.org/documentation/stubs/qiskit.circuit.library.ZZFeatureMap.html>` __, et du ` ` BasicAer ` ` ` ` qasm_simulateur ` ` utilisant 1024 coups.

[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’algorithme de regroupement spectral scikit-learn nous permet de définir [un noyau personnalisé] de deux manières: En fournissant un noyau en tant que fonction appelable ou en précalculant la matrice du noyau. En utilisant la class QuantumKernel dans Qiskit, nous pouvons utiliser que cette dernière.

Le code suivant précalcule et affiche les matrices de noyau avant de les fournir à l’algorithme de regroupement spectral scikit-learn, et de marquer les étiquettes à l’aide d’informations mutuelles normalisées, puisque nous connaissons a priori les labels des classes.

[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 a d’autres algorithmes qui peuvent utiliser une matrice de noyau précalculée, voici quelques uns:

  • Regroupement Agglomératif <https://scikit-learn.org/stable/modules/generated/sklearn.cluster.AgglomerativeClustering.html> __

  • Régression à vecteur de support <https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVR.html> __

  • Régression dorsale <https://scikit-learn.org/stable/modules/generated/sklearn.kernel_ridge.KernelRidge.html> __

  • Régression du processus Gaussien <https://scikit-learn.org/stable/modules/gaussian_process.html> __

  • Analyse en composantes principales <https://scikit-learn.org/stable/modules/generated/sklearn.decomposition.KernelPCA.html> __

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