Ghi chú

Trang này được tạo từ docs/tutorials/03_quantum_kernel.ipynb.

Nhân của trình học máy lượng tử

Nhiệm vụ chung của học máy là để tìm và nghiên cứu những mô hình trong dữ liệu. Với rất nhiều tập dữ liệu, các điểm dữ liệu có thể được hiểu tốt hơn trong những không gian tính năng với số chiều lớn hơn, do đó chúng sử dụng hàm hạt nhân: \(k(\vec{x}_i, \vec{x}_j) = \langle f(\vec{x}_i), f(\vec{x}_j) \rangle\) trong đó \(k\) là hàm hạt nhân, \(\vec{x}_i, \vec{x}_j\) là những đầu vào \(n\) chiều, \(f`là một ánh xạ từ không gian :math:`n\) chiều tới không gian \(m\) chiều và \(\langle a,b \rangle\) chỉ tích vô hướng. Khi xem xét một dữ liệu có hạn, một hàm hạt nhân có thể được viết dưới dạng mọt ma trận: \(K_{ij} = k(\vec{x}_i,\vec{x}_j)\).

Trong học máy nhân lượng tử, một ánh xạ tính năng lượng tử \(\phi(\vec{x})\) được sử dụng để ánh xạ một véc-tơ tính năng cổ điển \(\vec{x}\) cho một không gian Hilbert lượng tử, \(| \phi(\vec{x})\rangle \langle \phi(\vec{x})|\), sao cho \(K_{ij} = \left| \langle \phi^\dagger(\vec{x}_j)| \phi(\vec{x}_i) \rangle \right|^{2}\). Xem Supervised learning with quantum enhanced feature spaces để biết thêm chi tiết.

Trong notebook này, chúng tôi sử dụng qiskit để tính toán một ma trận nhân sử dụng một ánh xạ tính năng lượng tử, sau đó sử dụng ma trận nhân này trong các thuật toán phân loại và phân cụm scikit-learn.

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

Phân loại

Dành cho ví dụ về phân loại, chúng ta sẽ lại sử dụng tập dữ liệu ad hoc dataset như đã mô tả trong Supervised learning with quantum enhanced feature spaces, and thuật toán phân loại (svc) scikit-learn support vector machine.

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.

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.

Mã sau cung cấp nhân như một hàm có thể gọi được:

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

Mã sau đây tính toán trước và vẽ đồ thị sự đào tạo và thử nghiệm ma trận hạt nhân trước khi cung cấp chúng vào thuật toán scikit-learn svc:

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:

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

Cụm dữ liệu

Với ví dụ về cụm dữ liệu, chúng ta sẽ lại sử dụng tập dữ liệu ad hoc dataset như đã mô tả trong Supervised learning with quantum enhanced feature spaces, và thuật toán phân cụm dữ liệu scikit-learn spectral.

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.

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.

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.

Các mã sau đây tính trước và vẽ đồ thị các ma trận hạt nhân trước khi cung cấp nó cho các thuật toán phân cụm phổ scikit-learn, và ghi các nhãn bằng cách sử dụng thông tin chung được chuẩn hóa, vì thông thường chúng ta biết các nhãn lớp.

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 có các thuật toán khác có thể sử dụng ma trận hạt nhân (kernel matrix) được tính toán trước, đây là một số ít:

• Phân cụm sát nhập (Agglomerative Clustering)

• Véc-tơ hỗ trợ hồi quy

• Hồi quy Ridge

• Hồi quy của trình tự Gaussian

• Phân tích thành phần chính

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.