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

참고

이 페이지는 docs/tutorials/03_quantum_kernel.ipynb 에서 생성되었다.

양자 커널 기계 학습

일반적으로 기계학습은 데이터에서 패턴을 찾고 학습하는 것이다. 많은 양의 데이터에서 데이터 포인트들은 더 높은 차원의 특징 공간에서 더 잘 이해되어질 수 있는데, 이는 다음과 같은 커널 함수를 사용함으로써 가능해진다: \(k(\vec{x}_i, \vec{x}_j) = \langle f(\vec{x}_i), f(\vec{x}_j) \rangle\) 에서, \(k\) 는 커널 함수, \(\vec{x}_i, \vec{x}_j\)\(n\) 차원의 입력, \(f\)\(n\) 차원으로부터 \(m\) 차원 공간으로의 맵, 그리고 \(\langle a,b \rangle\) 는 내적을 의미한다. 유한한 데이터를 고려할 때, 커널 함수는 다음과 같은 행렬로서 표현될 수 있다: \(K_{ij} = k(\vec{x}_i,\vec{x}_j)\)

양자 커널 기계학습에서, 양자 특징 맵 \(\phi(\vec{x})\) 은 고전적인 특징 벡터 \(\vec{x}\) 를 양자 힐베르트 공간 \(| \phi(\vec{x})\rangle \langle \phi(\vec{x})|\) 으로 매핑하는데 쓰일 수 있는데, 예를 들면 \(K_{ij} = \left| \langle \phi^\dagger(\vec{x}_j)| \phi(\vec{x}_i) \rangle \right|^{2}\) 와 같다. 더 자세한 사항은 Supervised learning with quantum enhanced feature spaces 을 참조하라.

이 노트북 예제에서는 양자 특성 맵을 사용하여 커널 행렬을 계산하기 위해 qiskit 을 사용하였고, 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

분류

이 분류 예제에서는 Supervised learning with quantum enhanced feature spaces 에 설명된 바와 같이 ad hoc dataset 을 다시 사용할 것이고, scikit-learn support vector machine 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

학습 데이터와 테스트 데이터를 준비하고, QuantumKernel 클래스를 설정한다. 이는 ZZFeatureMap 과 1024개의 샷을 사용하는 BasicAer qasm_simulator 를 통해 커널 행렬을 계산하기 위함이다.

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

scikit-learn svc 알고리즘을 통해 사용자 정의 커널 을 두 가지 방법으로 정의할 수 있는데, 그 하나는 커널을 호출 가능한 함수로 제공하는 방법이고 다른 하나는 커널 행렬을 미리 계산하는 방법이다. qiskitQuantumKernel 클래스를 사용하여 이들 중 하나를 수행할 수 있다.

다음 코드는 커널을 호출 가능한 함수로 제공한다.

[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

다음 코드는 훈련 및 테스트 커널 행렬을 사전 계산하고 플로팅하여 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 은 또한 sklearn svc 를 상속한 qsvc 클래스를 포함하고 있으며 다음과 같이 사용할 수 있다.

[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

군집화

우리의 군집화 예제에서는 Supervised learning with quantum enhanced feature spaces 에 설명된 바와 같이 ad hoc dataset 를 다시 사용할 것이고, scikit-learn spectral 군집화 알고리즘을 사용할 것이다.

두 클래스 간에 큰 간격을 두고 데이터셋을 다시 생성하고, 군집화는 비지도학습 머신러닝 태스크이기 때문에 테스트 샘플은 준비하지 않는다.

[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

훈련 데이터 셋과 실험 데이터 셋을 준비하고, QuantumKernel 클래스를 다시 셋업한다. 이는 ZZFeatureMap 과 1024개의 샷을 사용하는 BasicAer qasm_simulator 를 통해 커널 행렬을 계산하기 위함이다.

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

scikit-learn 스펙트럼 클러스터링 알고리즘을 통해 [커스텀 커널] 을 두 가지 방법으로 정의할 수 있는데, 그 하나는 커널을 호출 가능한 함수로 제공하는 방법이고 다른 하나는 커널 매트릭스를 미리 계산하는 방법이다. qiskit의 QuantumKernel 클래스를 사용하면 두 번째 방법만 사용할 수 있다.

아래의 코드는 커널 행렬을 scikit-learn 스펙트럼 군집 알고리즘 적용전에 커널 행렬을 미리 계산하고 플롯팅한다. 우리는 클래스의 정답 라벨을 알고 있기 때문에 정규화된 상호정보(mutual information)를 사용하여 예측된 라벨을 채점한다.

[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 은 미리 계산된 커널 행렬을 사용할 수 있는 다른 알고리즘을 가지고 있는데, 이것들이 그 중 일부이다.

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