Not

Bu sayfa, docs/tutorials/03_quantum_kernel.ipynb sayfasından oluşturulmuştur.

Kuantum Çekirdek Makine Öğrenimi

Makine öğrenmesinin genel görevi, verilerdeki kalıpları bulmak ve incelemektir. Birçok veri kümesi için, veri noktaları daha yüksek boyutlu bir öznitelik uzayında, bir çekirdek fonksiyonu kullanılarak daha iyi anlaşılır: \(k(\vec{x}_i, \vec{x}_j) = \langle f(\ vec{x}_i), f(\vec{x}_j) \rangle\) burada \(k\) çekirdek fonksiyonudur, \(\vec{x}_i, \vec{x}_j\) \(n\) boyutlu girdiler, \(f\) \(n\)-boyutundan \(m\)-boyut uzayına ve \(\langle a,b \rangle\) arasındaki bir haritadır ve nokta çarpımını gösterir. Sonlu verileri dikkate alırken; bir çekirdek fonksiyonu, bir matris olarak temsil edilebilir: \(K_{ij} = k(\vec{x}_i,\vec{x}_j)\).

Kuantum çekirdek makine öğreniminde, bir kuantum öznitelik haritası \(\phi(\vec{x})\) klasik bir özellik vektörünü \(\vec{x}\) bir kuantum Hilbert uzayına eşlemek için kullanılır, \(| \phi(\vec{x})\rangle \langle \phi(\vec{x})|\), öyle ki \(K_{ij} = \left| \langle \phi^\dagger(\vec{x}_j)| \phi(\vec{x}_i) \rangle \right|^{2}\).Daha fazla ayrıntı için Supervised learning with quantum enhanced feature spaces bölümüne bakın.

Bu defterde, bir kuantum özellik haritası kullanarak bir çekirdek matrisini hesaplamak için qiskit kullanıyoruz, ardından bu çekirdek matrisini ``scikit-learn``de sınıflandırma ve kümeleme algoritmalarında kullanıyoruz.

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

Sınıflandırma

Sınıflandırma örneğimiz için, Supervised learning with quantum enhanced feature spaces ve scikit-learn ile denetimli öğrenme’de açıklandığı gibi ad hoc veri kümesini kullanacağız. support vector machine sınıflandırma (svc) algoritması.

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

ZZFeatureMap kullanarak bir çekirdek matrisi hesaplamak için QuantumKernel sınıfını ve 1024 deneme kullanarak BasicAer ``qasm_simulator``ı yeniden çalıştırdık.

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)

scikit-learn svc algoritması iki şekilde bir custom kernel tanımlamamıza olanak tanır: çekirdeği çağrılabilir bir fonksiyon olarak koşullayarak veya çekirdek matrisini önceden hesaplayarak.Bunlardan herhangi birini qiskit içindeki QuantumKernel sınıfını kullanarak yapabiliriz.

Takip eden kod, çekirdeği çağrılabilir bir fonksiyon olarak verir:

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

Aşağıdaki kod, eğitim ve test çekirdek matrislerini scikit-learn svc algoritmasına sağlamadan evvel önceden hesaplar ve çizer:

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 ayrıca sklearn svc sınıfını genişleten qsvc sınıfını da içerir ve aşağıdaki gibi kullanılabilir:

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

Kümelemek

Kümeleme örneğimiz için, yine Supervised learning with quantum enhanced feature spaces bölümünde açıklandığı gibi ad hoc veri kümesini ve scikit-learn spectral kümeleme algoritmasını kullanacağız.

Veri kümesini iki sınıf arasında daha büyük bir boşlukla yeniden oluşturacağız ve kümeleme denetimsiz bir makine öğrenimi görevi olduğundan, bir test örneğine ihtiyacımız yok.

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

ZZFeatureMap kullanarak bir çekirdek matrisi hesaplamak için QuantumKernel sınıfını ve 1024 deneme kullanarak BasicAer ``qasm_simulator``ı yeniden çalıştırdık.

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)

Scikit-learn spektral kümeleme algoritması, bir [özel çekirdek] tanımlamamızı iki şekilde sağlamaktadır: Çekirdeği çağrılabilir bir fonksiyon olarak temin ederek veya çekirdek matrisini önceden hesaplayarak sağlayabilir. Qiskit’te QuantumKernel sınıfını kullanarak, yalnızca ikincisini kullanabilmekteyiz.

The following code precomputes and plots the kernel matrices before providing it to the scikit-learn spectral clustering algorithm, and scoring the labels using normalized mutual information, since we a priori know the class labels.

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 önceden hesaplanmış bir çekirdek matrisi kullanabilen başka algoritmalara sahiptir, işte birkaçı:

• Agglomerative clustering

• Support vector regression

• Ridge regression

• Gaussian process regression

• Principal component analysis

import qiskit.tools.jupyter

%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit Software	Version
qiskit-terra	0.19.0
qiskit-aer	0.8.2
qiskit-ignis	0.6.0
qiskit-aqua	0.9.2
qiskit	0.27.0
qiskit-machine-learning	0.3.0
System information
Python	3.7.9 (default, Aug 31 2020, 17:10:11) [MSC v.1916 64 bit (AMD64)]
OS	Windows
CPUs	4
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.