Bengali
ভাষাসমূহ
English
Bengali
French
Hindi
Italian
Japanese
Korean
Malayalam
Russian
Spanish
Tamil
Turkish
Vietnamese
Shortcuts

নোট

এই পেজটি docs/tutorials/02_neural_network_classifier_and_regressor.ipynb থেকে তৈরি হয়েছে।

নিউরাল নেটওয়ার্ক শ্রেণিবিন্যাসকরক (ক্লাসিফায়ার) এবং রিগ্রেসর

এই পাঠসমূহ বা টিউটোরিয়ালে আমরা দেখাব কিভাবে NeuralNetworkClassifier এবং NeuralNetworkRegressor ব্যবহার করা হয়। উভয়ই একটি ইনপুট হিসাবে একটি (কোয়ান্টাম) NeuralNetwork গ্রহণ করে এবং একটি নির্দিষ্ট প্রসঙ্গে এটি লিভারেজ করে। উভয় ক্ষেত্রেই আমরা সুবিধার জন্য একটি পূর্ব-কনফিগার করা ভেরিয়েন্ট, ভেরিয়েশনাল কোয়ান্টাম ক্লাসিফায়ার (VQC) এবং ভেরিয়েশনাল কোয়ান্টাম রিগ্রসর (VQR) প্রদান করি। পাঠসমূহ (টিউটোরিয়াল) টি নিম্নরূপ গঠন করা হয়েছে:

  1. Classification

    • OpflowQNN সহ শ্রেণিবিন্যাসকরণ (ক্লাসিফিকেশন)

    • CircuitQNN সহ শ্রেণিবিন্যাসকরণ (ক্লাসিফিকেশন)

    • পরিবর্তনশীল (ভ্যারিয়েশনাল) কোয়ান্টাম শ্রেণিবিন্যাসকরক (ক্লাসিফায়ার) (ভি.কিউ.সি)

  2. Regression

    • OpflowQNN দিয়ে রিগ্রেশন

    • পরিবর্তনশীল (ভ্যারিয়েশনাল) কোয়ান্টাম রিগ্রেসর (ভি.কিউ.আর)

[1]:
import numpy as np
import matplotlib.pyplot as plt

from qiskit import Aer, QuantumCircuit
from qiskit.opflow import Z, I, StateFn
from qiskit.utils import QuantumInstance
from qiskit.circuit import Parameter
from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap
from qiskit.algorithms.optimizers import COBYLA, L_BFGS_B

from qiskit_machine_learning.neural_networks import TwoLayerQNN, CircuitQNN
from qiskit_machine_learning.algorithms.classifiers import NeuralNetworkClassifier, VQC
from qiskit_machine_learning.algorithms.regressors import NeuralNetworkRegressor, VQR

from typing import Union

from qiskit_machine_learning.exceptions import QiskitMachineLearningError

from IPython.display import clear_output
[2]:
quantum_instance = QuantumInstance(Aer.get_backend('aer_simulator'), shots=1024)

শ্রেণিবিভাগ (ক্লাসিফিকেশন)

এই ধারাক্রম (অ্যালগোরিদম​) কে বোঝানোর জন্য আমরা একটি সহজ শ্রেণিবিন্যাসকরণ তথ্যশালা (ক্লাসিফিকেশন ডাটাসেট​) বানিয়েছি।

[3]:
num_inputs = 2
num_samples = 20
X = 2*np.random.rand(num_samples, num_inputs) - 1
y01 = 1*(np.sum(X, axis=1) >= 0)  # in { 0,  1}
y = 2*y01-1                       # in {-1, +1}
y_one_hot = np.zeros((num_samples, 2))
for i in range(num_samples):
    y_one_hot[i, y01[i]] = 1

for x, y_target in zip(X, y):
    if y_target == 1:
        plt.plot(x[0], x[1], 'bo')
    else:
        plt.plot(x[0], x[1], 'go')
plt.plot([-1, 1], [1, -1], '--', color='black')
plt.show()
../_images/tutorials_02_neural_network_classifier_and_regressor_4_0.png

OpflowQNN সহ শ্রেণিবিন্যাসকরণ (ক্লাসিফিকেশন)

প্রথমে আমরা দেখি কীভাবে একটি OpflowQNN-এর মধ্যে শ্রেণিবিন্যাসের জন্য একটি NeuralNetworkClassifier ব্যবহার করা যায়। এই প্রসঙ্গে, OpflowQNN \([-1, +1]\) তে এক-মাত্রিক আউটপুট ফেরত প্রত্যাশিত। এটি শুধুমাত্র বাইনারি শ্রেণিবিন্যাসের জন্য কাজ করে এবং আমরা দুটি ক্লাসকে \(\{-1, +1\}\) এ বরাদ্দ করি। সুবিধার জন্য, আমরা TwoLayerQNN ব্যবহার করি, যা একটি বিশেষ ধরণের OpflowQNN যা বৈশিষ্ট্যের মানচিত্র এবং আনস্যাটজের মাধ্যমে সংজ্ঞায়িত করা হয়।

[4]:
# construct QNN
opflow_qnn = TwoLayerQNN(num_inputs, quantum_instance=quantum_instance)
[5]:
# QNN maps inputs to [-1, +1]
opflow_qnn.forward(X[0, :], np.random.rand(opflow_qnn.num_weights))
[5]:
array([[0.47265625]])

আমরা callback_graph নামে একটি কলব্যাক ফাংশন যোগ করব। এটি অপ্টিমাইজারের প্রতিটি পুনরাবৃত্তির জন্য বলা হবে এবং দুটি পরামিতি পাস করা হবে: বর্তমান ওজন এবং সেই ওজনগুলিতে উদ্দেশ্যমূলক কাজের মান। আমাদের ফাংশনের জন্য, আমরা উদ্দেশ্য ফাংশনের মানকে একটি অ্যারেতে যুক্ত করি যাতে আমরা পুনরাবৃত্তি বনাম বস্তুনিষ্ঠ ফাংশন ভ্যালু প্লট করতে পারি এবং প্রতিটি পুনরাবৃত্তির সাথে গ্রাফ আপডেট করতে পারি। যাইহোক, আপনি কলব্যাক ফাংশন দিয়ে যতটুকু চান তা করতে পারেন যতক্ষণ না এটি দুটি প্যারামিটার পাস করে।

[6]:
# callback function that draws a live plot when the .fit() method is called
def callback_graph(weights, obj_func_eval):
    clear_output(wait=True)
    objective_func_vals.append(obj_func_eval)
    plt.title("Objective function value against iteration")
    plt.xlabel("Iteration")
    plt.ylabel("Objective function value")
    plt.plot(range(len(objective_func_vals)), objective_func_vals)
    plt.show()
[7]:
# construct neural network classifier
opflow_classifier = NeuralNetworkClassifier(opflow_qnn, optimizer=COBYLA(), callback=callback_graph)
[8]:
# create empty array for callback to store evaluations of the objective function
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)

# fit classifier to data
opflow_classifier.fit(X, y)

# return to default figsize
plt.rcParams["figure.figsize"] = (6, 4)

# score classifier
opflow_classifier.score(X, y)
../_images/tutorials_02_neural_network_classifier_and_regressor_11_0.png
[8]:
0.5
[9]:
# evaluate data points
y_predict = opflow_classifier.predict(X)

# plot results
# red == wrongly classified
for x, y_target, y_p in zip(X, y, y_predict):
    if y_target == 1:
        plt.plot(x[0], x[1], 'bo')
    else:
        plt.plot(x[0], x[1], 'go')
    if y_target != y_p:
        plt.scatter(x[0], x[1], s=200, facecolors='none', edgecolors='r', linewidths=2)
plt.plot([-1, 1], [1, -1], '--', color='black')
plt.show()
../_images/tutorials_02_neural_network_classifier_and_regressor_12_0.png

CircuitQNN সহ শ্রেণিবিন্যাসকরণ (ক্লাসিফিকেশন)

পরবর্তী আমরা দেখাব কিভাবে একটি CircuitQNN একটি NeuralNetworkClassifier এর মধ্যে শ্রেণিবিন্যাসের জন্য ব্যবহার করা যেতে পারে। এই প্রেক্ষাপটে, CircuitQNN প্রত্যাশিত হবে: \(d\)- মাত্রিক সম্ভাবনা ভেক্টর আউটপুট হিসাবে, যেখানে \(d\)-শ্রেণীর সংখ্যা নির্দেশ করে কোনও QuantumCircuit থেকে নমুনা দেওয়ার ফলে স্বয়ংক্রিয়ভাবে সম্ভাবনা বন্টনের ফলাফল হয় এবং আমাদের কেবলমাত্র পরিমাপ করা বিটস্ট্রিংগুলি থেকে বিভিন্ন শ্রেণিতে ম্যাপিং সংজ্ঞায়িত করতে হবে। বাইনারি শ্রেণিবিন্যাসের জন্য আমরা প্যারিটি ম্যাপিং ব্যবহার করি।

[10]:
# construct feature map
feature_map = ZZFeatureMap(num_inputs)

# construct ansatz
ansatz = RealAmplitudes(num_inputs, reps=1)

# construct quantum circuit
qc = QuantumCircuit(num_inputs)
qc.append(feature_map, range(num_inputs))
qc.append(ansatz, range(num_inputs))
qc.decompose().draw(output='mpl')
[10]:
../_images/tutorials_02_neural_network_classifier_and_regressor_14_0.png
[11]:
# parity maps bitstrings to 0 or 1
def parity(x):
    return '{:b}'.format(x).count('1') % 2
output_shape = 2  # corresponds to the number of classes, possible outcomes of the (parity) mapping.
[12]:
# construct QNN
circuit_qnn = CircuitQNN(circuit=qc,
                         input_params=feature_map.parameters,
                         weight_params=ansatz.parameters,
                         interpret=parity,
                         output_shape=output_shape,
                         quantum_instance=quantum_instance)
[13]:
# construct classifier
circuit_classifier = NeuralNetworkClassifier(neural_network=circuit_qnn,
                                             optimizer=COBYLA(),
                                             callback=callback_graph)
[14]:
# create empty array for callback to store evaluations of the objective function
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)

# fit classifier to data
circuit_classifier.fit(X, y01)

# return to default figsize
plt.rcParams["figure.figsize"] = (6, 4)

# score classifier
circuit_classifier.score(X, y01)
../_images/tutorials_02_neural_network_classifier_and_regressor_18_0.png
[14]:
0.65
[15]:
# evaluate data points
y_predict = circuit_classifier.predict(X)

# plot results
# red == wrongly classified
for x, y_target, y_p in zip(X, y01, y_predict):
    if y_target == 1:
        plt.plot(x[0], x[1], 'bo')
    else:
        plt.plot(x[0], x[1], 'go')
    if y_target != y_p:
        plt.scatter(x[0], x[1], s=200, facecolors='none', edgecolors='r', linewidths=2)
plt.plot([-1, 1], [1, -1], '--', color='black')
plt.show()
../_images/tutorials_02_neural_network_classifier_and_regressor_19_0.png

পরিবর্তনশীল (ভ্যারিয়েশনাল) কোয়ান্টাম শ্রেণিবিন্যাসকরক (ক্লাসিফায়ার) (ভি.কিউ.সি)

VQC একটি CircuitQNN সহ NeuralNetworkClassifier এর একটি বিশেষ রূপ। এটি শ্রেণিবিন্যাসের বিটস্ট্রিং থেকে মানচিত্রের জন্য একটি প্যারিটি ম্যাপিং (বা একাধিক ক্লাসে এক্সটেনশনগুলি) প্রয়োগ করে, যার ফলস্বরূপ সম্ভাবনা ভেক্টর তৈরি হয়, যা এক-হট এনকোডযুক্ত ফলাফল হিসাবে ব্যাখ্যা করা হয়। ডিফল্টরূপে , এটি এই CrossEntropyLoss ফাংশনটি প্রয়োগ করে যা এক-হট এনকোডযুক্ত ফর্ম্যাটে দেওয়া লেবেলগুলির প্রত্যাশা করে এবং সেই ফর্ম্যাটেও পূর্বাভাস প্রত্যাবর্তন করবে।

[16]:
# construct feature map, ansatz, and optimizer
feature_map = ZZFeatureMap(num_inputs)
ansatz = RealAmplitudes(num_inputs, reps=1)

# construct variational quantum classifier
vqc = VQC(feature_map=feature_map,
          ansatz=ansatz,
          loss='cross_entropy',
          optimizer=COBYLA(),
          quantum_instance=quantum_instance,
          callback=callback_graph)
[17]:
# create empty array for callback to store evaluations of the objective function
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)

# fit classifier to data
vqc.fit(X, y_one_hot)

# return to default figsize
plt.rcParams["figure.figsize"] = (6, 4)

# score classifier
vqc.score(X, y_one_hot)
../_images/tutorials_02_neural_network_classifier_and_regressor_22_0.png
[17]:
0.6
[18]:
# evaluate data points
y_predict = vqc.predict(X)

# plot results
# red == wrongly classified
for x, y_target, y_p in zip(X, y_one_hot, y_predict):
    if y_target[0] == 1:
        plt.plot(x[0], x[1], 'bo')
    else:
        plt.plot(x[0], x[1], 'go')
    if not np.all(y_target == y_p):
        plt.scatter(x[0], x[1], s=200, facecolors='none', edgecolors='r', linewidths=2)
plt.plot([-1, 1], [1, -1], '--', color='black')
plt.show()
../_images/tutorials_02_neural_network_classifier_and_regressor_23_0.png

রিগ্রেশন

এই ধারাক্রম গুলিকে (অ্যালগোরিদমস​​) কে বোঝানোর জন্য আমরা একটি সহজ রিগ্রেশন​ তথ্যশালা (ডাটাসেট​) বানাই।

[19]:
num_samples = 20
eps = 0.2
lb, ub = -np.pi, np.pi
X_ = np.linspace(lb, ub, num=50).reshape(50, 1)
f = lambda x: np.sin(x)

X = (ub - lb)*np.random.rand(num_samples, 1) + lb
y = f(X[:,0]) + eps*(2*np.random.rand(num_samples)-1)

plt.plot(X_, f(X_), 'r--')
plt.plot(X, y, 'bo')
plt.show()
../_images/tutorials_02_neural_network_classifier_and_regressor_25_0.png

OpflowQNN দিয়ে রিগ্রেশন

এই সহায়িকাতে আমরা OpflowQNN রিগ্রেশন ব্যবহার করব যা আমাদের \([-1, +1]\) ভ্যালু দিবে। আরো জটিল এবং বহুমাত্রিক মডেল এই রিগ্রেশন দ্বারা তৈরি করা যাবে, এই ক্ষেত্রে আমাদের CircuitQNN ব্যবহার করতে হবে, যা এই সহায়িকার বা টিউটোরিয়ালের সীমার বাইরে।

[20]:
# construct simple feature map
param_x = Parameter('x')
feature_map = QuantumCircuit(1, name='fm')
feature_map.ry(param_x, 0)

# construct simple ansatz
param_y = Parameter('y')
ansatz = QuantumCircuit(1, name='vf')
ansatz.ry(param_y, 0)

# construct QNN
regression_opflow_qnn = TwoLayerQNN(1, feature_map, ansatz, quantum_instance=quantum_instance)
[21]:
# construct the regressor from the neural network
regressor = NeuralNetworkRegressor(neural_network=regression_opflow_qnn,
                                   loss='l2',
                                   optimizer=L_BFGS_B(),
                                   callback=callback_graph)
[22]:
# create empty array for callback to store evaluations of the objective function
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)

# fit to data
regressor.fit(X, y)

# return to default figsize
plt.rcParams["figure.figsize"] = (6, 4)

# score the result
regressor.score(X, y)
../_images/tutorials_02_neural_network_classifier_and_regressor_29_0.png
[22]:
0.9696567935175576
[23]:
# plot target function
plt.plot(X_, f(X_), 'r--')

# plot data
plt.plot(X, y, 'bo')

# plot fitted line
y_ = regressor.predict(X_)
plt.plot(X_, y_, 'g-')
plt.show()
../_images/tutorials_02_neural_network_classifier_and_regressor_30_0.png

পরিবর্তনশীল (ভ্যারিয়েশনাল) কোয়ান্টাম রিগ্রেশর (VQR) দ্বারা রিগ্রেশন।

VQC শ্রেণিবিন্যাসকরণ (ক্লাসিফিকেশন) এর মতই VQR একটি বিশেষ প্রকরণ যা NeuralNetworkRegressor এবং OpflowQNN এর অন্তর্ভুক্ত। স্বতঃসিদ্ধ নিয়মানুসারে এটি একটি L2Loss ফাংশন যা অনুমান (প্রেডিকশন) এবং প্রত্যাশিত ফলাফল (টারগেট) এর গড় বর্গ মান অবনমন (মিনিমাইজ) করে।

[24]:
vqr = VQR(feature_map=feature_map,
          ansatz=ansatz,
          optimizer=L_BFGS_B(),
          quantum_instance=quantum_instance,
          callback=callback_graph)
[25]:
# create empty array for callback to store evaluations of the objective function
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)

# fit regressor
vqr.fit(X, y)

# return to default figsize
plt.rcParams["figure.figsize"] = (6, 4)

# score result
vqr.score(X, y)
../_images/tutorials_02_neural_network_classifier_and_regressor_33_0.png
[25]:
0.9684356876095139
[26]:
# plot target function
plt.plot(X_, f(X_), 'r--')

# plot data
plt.plot(X, y, 'bo')

# plot fitted line
y_ = vqr.predict(X_)
plt.plot(X_, y_, 'g-')
plt.show()
../_images/tutorials_02_neural_network_classifier_and_regressor_34_0.png
[27]:
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit SoftwareVersion
qiskit-terra0.19.0.dev0+803bd0d
qiskit-aer0.8.2
qiskit-machine-learning0.3.0
System information
Python3.9.6 (default, Aug 18 2021, 15:44:49) [MSC v.1916 64 bit (AMD64)]
OSWindows
CPUs4
Memory (Gb)11.83804702758789
Sun Aug 29 01:09:16 2021 Hora de verano romance

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.