Hindi
भाषाएँ
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\) are \(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, और scikit-learn support vector machine वर्गीकरण (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

हमारे प्रशिक्षण और परीक्षण डेटासेट तैयार होने के साथ, हम ZZFeatureMap और BasicAer qasm_simulator 1024 शॉट्स का उपयोग करके कर्नेल मैट्रिक्स की गणना करने के लिए QuantumKernel वर्ग की स्थापना करते हैं।

[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 एल्गोरिथम हमें एक कस्टम कर्नेल को दो तरह से परिभाषित करने की अनुमति देता है: कर्नेल को कॉल करने योग्य फ़ंक्शन के रूप में प्रदान करके या कर्नेल मैट्रिक्स को प्रीकंप्यूटिंग करके। हम इनमें से कोई भी qiskit में QuantumKernel वर्ग का उपयोग करके कर सकते हैं।

निम्नालिखित कोड कर्नेल को कॉल करने योग्य फ़ंक्शन के रूप में देता है:

[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 एल्गोरिथम प्रदान करने से पहले प्रशिक्षण और परीक्षण कर्नेल matrices को प्रीकंप्यूट करता है और प्लॉट करता है:

[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 में qsvc वर्ग भी शामिल है जो sklearn svc वर्ग का विस्तार करता है, जिसका उपयोग निम्नानुसार किया जा सकता है:

[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, और 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

हमने ZZFeatureMap, और १०२४ शॉट्स का उपयोग करते BasicAer qasm_simulator का उपयोग करके कर्नेल मैट्रिक्स की गणना करने के लिए फिर से QuantumKernel वर्ग की स्थापना की।

[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 में QuantumKernelQiskit वर्ग का उपयोग करके, हम केवल बाद वाले तरीके का उपयोग कर सकते हैं।

निम्न कोड scikit-learn स्पेक्ट्रल क्लस्टरिंग एल्गोरिथम को प्रदान करने से पहले कर्नेल मैट्रिस को प्रीकंप्यूट और प्लॉट करता है, और सामान्यीकृत पारस्परिक जानकारी का उपयोग करके लेबल को स्कोर करता है, क्योंकि हम एक प्राथमिकता वर्ग लेबल जानते हैं।

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