Malayalam
ഭാഷകൾ
English
Bengali
French
Hindi
Italian
Japanese
Korean
Malayalam
Russian
Spanish
Tamil
Turkish
Vietnamese
Shortcuts

Note

This page was generated from 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 ക്ലാസ്സിഫിക്കേഷനിലും ക്ലസ്റ്ററിംഗ് അൽഗോരിതങ്ങളിലും ഈ കേർണൽ മാട്രിക്സ് ഉപയോഗിക്കുന്നു.

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

Classification

ഞമ്മളുടെ വർഗ്ഗീകരണ ഉദാഹരണത്തിനായി, Supervised learning with quantum enhanced feature spaces പഠനത്തിൽ വിവരിച്ചിരിക്കുന്നതുപോലെ ad hoc dataset ഉം, കൂടാതെ 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.0)
plt.title("Ad hoc dataset for classification")

plt.show()
../_images/tutorials_03_quantum_kernel_3_0.png

ഞമ്മളുടെ പരിശീലനവും പരിശോധന ഡാറ്റാസെറ്റുകളും തയ്യാറായതോടെ, the ZZFeatureMap ഉപയോഗിച്ച് ഒരു കേർണൽ മാട്രിക്സ് കണക്കാക്കാൻ ഞമ്മൾ QuantumKernel ക്ലാസ് സജ്ജമാക്കുന്നു. കൂടാതെ 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)

ഒരു custom kernel <https://scikit-learn.org/stable/modules/svm.html#custom-kernels>`__നെ രണ്ട് തരത്തിൽ നിർവചിക്കാൻ ``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 അൽ‌ഗോരിതം നൽകുന്നതിനുമുമ്പ് ഇനിപ്പറയുന്ന കോഡ് മുൻ‌കൂട്ടി തയ്യാറാക്കുകയും പ്ലോട്ട് ചെയ്യുകയും ചെയ്യുന്നു:

[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

qiskitsklearn 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.0)
plt.title("Ad hoc dataset for clustering")

plt.show()
../_images/tutorials_03_quantum_kernel_13_0.png

ഞമ്മളുടെ പരിശീലനവും പരിശോധന ഡാറ്റാസെറ്റുകളും തയ്യാറായതോടെ, ZZFeatureMap ഉപയോഗിച്ച് ഒരു കേർണൽ മാട്രിക്സ് കണക്കാക്കാൻ വീണ്ടും ഞമ്മൾ QuantumKernal ക്ലാസ് സജ്ജമാക്കുന്നു. കൂടാതെ 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)

ഒരു [custom kernel] -നെ രണ്ട് തരത്തിൽ നിർവചിക്കാൻ സൈകിറ്റ്-ലേൺ സ്പെക്ട്രൽ ക്ലസ്റ്ററിംഗ് അൽ‌ഗോരിതം നമ്മളെ അനുവദിക്കുന്നു: കേർ‌ണലിനെ വിളിക്കാൻ‌ കഴിയുന്ന പ്രവർ‌ത്തനമായി നൽ‌കുന്നതിലൂടെ അല്ലെങ്കിൽ‌ കേർ‌ണൽ‌ മാട്രിക്സ് മുൻ‌കൂട്ടി കംപ്യൂട്ട് ചെയ്യുന്നതിലൂടെ. ക്വിസ്‌കിറ്റ്ലെ ക്വാണ്ടം കേർണൽ ക്ലാസ് ഉപയോഗിച്ച് നമുക്ക് ഇവയിലേതെങ്കിലും ചെയ്യാൻ കഴിയുന്നതാണ്.

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 (സൈകിറ്റ്-ലേണി)-ന് ഉണ്ട്, അവയിൽ ചിലത് ഇതാ:

[1]:
import qiskit.tools.jupyter

%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit SoftwareVersion
qiskit-terra0.19.0
qiskit-aer0.8.2
qiskit-ignis0.6.0
qiskit-aqua0.9.2
qiskit0.27.0
qiskit-machine-learning0.3.0
System information
Python3.7.9 (default, Aug 31 2020, 17:10:11) [MSC v.1916 64 bit (AMD64)]
OSWindows
CPUs4
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.