নোট

এই পেজটি 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\) হচ্ছে ডট গুণন। যখন কোন সসীম ডাটা হিসাব করা হয় তখন, কার্নেল ফাংশন কে রিপ্রেসেন্ট করা হয় : :math:`K_{ij} = k(vec{x}_i,vec{x}_j)`এই ম্যাট্রিক্স দ্বারা।

কার্নেল মেশিন লার্নিং এ ক্লাসিক্যাল ফিচার ভেক্টর \(\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}\) এ ম্যাপিং করে গুছিয়ে নিতে একটি কোয়ান্টাম ফিচার ম্যাপ \(\phi(\vec{x})\) ব্যবহৃত হয়। আরও জানতে Supervised learning with quantum enhanced feature spaces পেপারটি দেখুন।

এই নোটবুকে আমরা কোয়ান্টাম ফিচার ম্যাপ ব্যবহার করে কার্নেল ম্যাটিক্স হিসাব করতে qiskit ব্যবহার করব। তারপরে এই কার্নেল ম্যাটিক্সটি ``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.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 ক্লাসিফিকেশন (svc) অ্যালোগরিদমটি ব্যবহার করব।

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

ট্রেনিং এবং টেস্টিং ডেটাসেট তৈরি হওয়ার পর আমরা ZZFeatureMap এবং BasicAer qasm_simulator এ ১০২৪ ষটস(shots) দিয়ে QuantumKernel ক্লাসটি সেট করে দেব।

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 অ্যালোগরিদমটি একটি custom kernel বর্ণনা করতে দুইভাবে সাহায্য করতে পারে: কার্নেলটাকে একটা কলযোগ্য ফাংশন হিসেবে প্রস্তুত করার মাধ্যমে অথবা কার্নেল ম্যাট্রিক্সটি আগেই হিসাব করার মাধ্যমে। আমরা এই দুটো পদ্ধতিই qiskit এর QuantumKernel ক্লাস ব্যবহার করে করতে পারি।

নিম্নলিখিত কোডটি কার্নেলকে একটি কলযোগ্য ফাংশন হিসেবে দেয়।

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 অ্যালোগরিদমে পাঠিয়ে দেয়ার আগে টেস্টিং কার্নেল ম্যাট্রিক্সগুলোকে স্পথাপন করে।

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 এ qsvc ক্লাস(class) থাকে যা sklearn svc ক্লাসকে বর্ধিত করে, এটা নিম্নলিখিত উপায়ে ব্যবহৃত হয়:

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 ক্লাস্টারিং অ্যালোগরিদমের মধ্যে ad hoc dataset ব্যবহার করব।

আমরা দুটি ক্লাসের ভেতর বিশাল গ্যাপ দিয়ে পুনরায় ডেটাসেটটি সৃষ্টি করব। যেহেতু ক্লাস্টারিং হল এক প্রকার আনসুপারভাইজড মেশিন লার্নিং কাজ, কাজেই আমাদের কোনো টেস্ট স্যাম্পল প্রয়োজন নেই।

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

আবারও আমরা ZZFeatureMap ব্যবহার করে একটি কার্নেল ম্যাট্রিক্স এবং ১০২৪ শটস(shots) এর মাধ্যমে BasicAer qasm_simulator দিয়ে হিসাব করতে QuantumKernel ক্লাসটি বসাব।

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 স্পেক্ট্রাল অ্যালোগরিদমে পাঠিয়ে দেয়ার আগে এবং যেহেতু আমরা আগে থেকেই ক্লাস লেবেলগুলো জানি, তাই এই লেবেলগুলোকে নরমালাইজড মিউচুয়াল ইনফরমেশন (normalized_mutual_info_score) স্কোর করেই তারপর টেস্টিং কার্নেল ম্যাট্রিক্সগুলোকে স্পথাপন করে।

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 এর অন্যান্য অ্যালোগরিদমসমূহ আছে যেগুলো কার্নেল ম্যাট্রিক্স আগেভাগে হিসাব করার কাজে ব্যবহৃত হয়। তন্মধ্যে কিছুসংখ্যক নিম্নরুপ,

• Agglomerative clustering

• Support vector regression

• Ridge regression

• Gaussian process regression

• Principal component analysis

import qiskit.tools.jupyter

%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit Software	Version
qiskit-terra	0.19.0
qiskit-aer	0.8.2
qiskit-ignis	0.6.0
qiskit-aqua	0.9.2
qiskit	0.27.0
qiskit-machine-learning	0.3.0
System information
Python	3.7.9 (default, Aug 31 2020, 17:10:11) [MSC v.1916 64 bit (AMD64)]
OS	Windows
CPUs	4
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.