Vietnamese
Ngôn ngữ
English
Bengali
French
Hindi
Italian
Japanese
Korean
Malayalam
Russian
Spanish
Tamil
Turkish
Vietnamese
Shortcuts

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\) 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.

[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

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.

[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

Với việc đào tạo và thử dữ liệu kiểm tra sẵn sàng, chúng tôi thiết lập lớp QuantumKernel để tính một ma trận hạt nhân bằng cách sử dụng ZZFeatureMap, và BasicAer qasm_simulator với 1024 lần chạy.

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

Thuật toán scikit-learn svc cho phép chúng ta xác định nhân tùy chỉnh theo hai cách: bằng cách cung cấp nhân như một hàm có thể gọi được hoặc bằng cách tính toán trước ma trận hạt nhân. Chúng ta có thể dùng một trong hai cách này bằng cách sử dụng lớp QuantumKernel trong qiskit.

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

[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

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:

[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 cũng chứa lớp qsvc để mở rộng lớp sklearn svc, có thể được sử dụng như sau:

[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

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.

Chúng ta sẽ tái tạo tập dữ liệu với khoảng cách lớn hơn giữa hai lớp, và vì cụm dữ liệu là một nhiệm vụ học máy không giám sát, chúng ta không cần mẫu thử nghiệm.

[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

Chúng tôi một lần nữa thiết lập lớp QuantumKernel để tính một ma trận hạt nhân bằng cách sử dụng ZZFeatureMap, và BasicAer qasm_simulator sử dụng 1024 lần chạy.

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

Thuật toán phân cụm phổ scikit-learn cho phép chúng ta xác định một [hạt nhân tùy chỉnh] theo hai cách: bằng cách cung cấp hạt nhân như một hàm có thể gọi được hoặc bằng cách tính toán trước ma trận hạt nhân. Sử dụng lớp QuantumKernel trong qiskit, chúng ta chỉ có thể sử dụng cách thứ hai.

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.

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

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