 TensorFlow.org এ দেখুন |  Google Colab-এ চালান |  GitHub-এ উৎস দেখুন |  নোটবুক ডাউনলোড করুন |
এই টিউটোরিয়ালটি একটি কোয়ান্টাম নিউরাল নেটওয়ার্ক (QNN) তৈরি করে MNIST-এর একটি সরলীকৃত সংস্করণকে শ্রেণীবদ্ধ করতে, যা Farhi et al-এ ব্যবহৃত পদ্ধতির অনুরূপ। এই ধ্রুপদী ডেটা সমস্যায় কোয়ান্টাম নিউরাল নেটওয়ার্কের কর্মক্ষমতা একটি ক্লাসিক্যাল নিউরাল নেটওয়ার্কের সাথে তুলনা করা হয়।
সেটআপ
pip install tensorflow==2.7.0
টেনসরফ্লো কোয়ান্টাম ইনস্টল করুন:
pip install tensorflow-quantum
# Update package resources to account for version changes.
import importlib, pkg_resources
importlib.reload(pkg_resources)
<module 'pkg_resources' from '/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/pkg_resources/__init__.py'>
এখন TensorFlow এবং মডিউল নির্ভরতা আমদানি করুন:
import tensorflow as tf
import tensorflow_quantum as tfq
import cirq
import sympy
import numpy as np
import seaborn as sns
import collections
# visualization tools
%matplotlib inline
import matplotlib.pyplot as plt
from cirq.contrib.svg import SVGCircuit
2022-02-04 12:29:39.759643: E tensorflow/stream_executor/cuda/cuda_driver.cc:271] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected
1. ডেটা লোড করুন
এই টিউটোরিয়ালে আপনি ফারহি এট আল অনুসরণ করে 3 এবং 6 সংখ্যার মধ্যে পার্থক্য করার জন্য একটি বাইনারি ক্লাসিফায়ার তৈরি করবেন। এই বিভাগে ডেটা হ্যান্ডলিং কভার করে যা:
- কেরাস থেকে কাঁচা ডেটা লোড করে।
- শুধুমাত্র 3s এবং 6s এ ডেটাসেট ফিল্টার করে।
- ছবিগুলিকে ডাউনস্কেল করে যাতে সেগুলি একটি কোয়ান্টাম কম্পিউটারে ফিট করতে পারে৷
- কোনো পরস্পরবিরোধী উদাহরণ মুছে দেয়।
- বাইনারি চিত্রগুলিকে Cirq সার্কিটে রূপান্তরিত করে।
- Cirq সার্কিটকে TensorFlow কোয়ান্টাম সার্কিটে রূপান্তর করে।
1.1 কাঁচা ডেটা লোড করুন
কেরাসের সাথে বিতরণ করা MNIST ডেটাসেট লোড করুন।
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
# Rescale the images from [0,255] to the [0.0,1.0] range.
x_train, x_test = x_train[..., np.newaxis]/255.0, x_test[..., np.newaxis]/255.0
print("Number of original training examples:", len(x_train))
print("Number of original test examples:", len(x_test))
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz 11493376/11490434 [==============================] - 0s 0us/step 11501568/11490434 [==============================] - 0s 0us/step Number of original training examples: 60000 Number of original test examples: 10000
শুধুমাত্র 3s এবং 6s রাখতে ডেটাসেটটি ফিল্টার করুন, অন্যান্য ক্লাসগুলি সরিয়ে দিন। একই সময়ে লেবেল, y , বুলিয়ানে রূপান্তর করুন: 3 -এর জন্য True এবং 6-এর জন্য False ।
def filter_36(x, y):
keep = (y == 3) | (y == 6)
x, y = x[keep], y[keep]
y = y == 3
return x,y
x_train, y_train = filter_36(x_train, y_train)
x_test, y_test = filter_36(x_test, y_test)
print("Number of filtered training examples:", len(x_train))
print("Number of filtered test examples:", len(x_test))
Number of filtered training examples: 12049 Number of filtered test examples: 1968
প্রথম উদাহরণ দেখান:
print(y_train[0])
plt.imshow(x_train[0, :, :, 0])
plt.colorbar()
True <matplotlib.colorbar.Colorbar at 0x7fac6ad4bd90>
1.2 ইমেজ ডাউনস্কেল
বর্তমান কোয়ান্টাম কম্পিউটারের জন্য 28x28 এর একটি চিত্রের আকার অনেক বড়। ছবিটির আকার 4x4 এ নামিয়ে দিন:
x_train_small = tf.image.resize(x_train, (4,4)).numpy()
x_test_small = tf.image.resize(x_test, (4,4)).numpy()
আবার, প্রথম প্রশিক্ষণের উদাহরণ প্রদর্শন করুন — আকার পরিবর্তনের পরে:
print(y_train[0])
plt.imshow(x_train_small[0,:,:,0], vmin=0, vmax=1)
plt.colorbar()
True <matplotlib.colorbar.Colorbar at 0x7fabf807fe10>
1.3 পরস্পরবিরোধী উদাহরণ সরান
বিভাগ 3.3 থেকে ফারহি এট আল-এর ডিজিটস আলাদা করা শেখা। , উভয় শ্রেণীর অন্তর্গত হিসাবে লেবেল করা ছবিগুলি সরাতে ডেটাসেট ফিল্টার করুন।
এটি একটি প্রমিত মেশিন-লার্নিং পদ্ধতি নয়, তবে কাগজটি অনুসরণ করার স্বার্থে অন্তর্ভুক্ত।
def remove_contradicting(xs, ys):
mapping = collections.defaultdict(set)
orig_x = {}
# Determine the set of labels for each unique image:
for x,y in zip(xs,ys):
orig_x[tuple(x.flatten())] = x
mapping[tuple(x.flatten())].add(y)
new_x = []
new_y = []
for flatten_x in mapping:
x = orig_x[flatten_x]
labels = mapping[flatten_x]
if len(labels) == 1:
new_x.append(x)
new_y.append(next(iter(labels)))
else:
# Throw out images that match more than one label.
pass
num_uniq_3 = sum(1 for value in mapping.values() if len(value) == 1 and True in value)
num_uniq_6 = sum(1 for value in mapping.values() if len(value) == 1 and False in value)
num_uniq_both = sum(1 for value in mapping.values() if len(value) == 2)
print("Number of unique images:", len(mapping.values()))
print("Number of unique 3s: ", num_uniq_3)
print("Number of unique 6s: ", num_uniq_6)
print("Number of unique contradicting labels (both 3 and 6): ", num_uniq_both)
print()
print("Initial number of images: ", len(xs))
print("Remaining non-contradicting unique images: ", len(new_x))
return np.array(new_x), np.array(new_y)
ফলাফলের সংখ্যাগুলি রিপোর্ট করা মানগুলির সাথে ঘনিষ্ঠভাবে মেলে না, তবে সঠিক পদ্ধতিটি নির্দিষ্ট করা নেই৷
এখানে এটাও লক্ষণীয় যে এই মুহুর্তে ফিল্টারিং পরস্পর বিরোধী উদাহরণ প্রয়োগ করা মডেলটিকে পরস্পর বিরোধী প্রশিক্ষণের উদাহরণ প্রাপ্ত করা থেকে সম্পূর্ণরূপে বাধা দেয় না: পরবর্তী ধাপটি ডেটা বাইনারি করে যা আরও সংঘর্ষের কারণ হবে।
x_train_nocon, y_train_nocon = remove_contradicting(x_train_small, y_train)
Number of unique images: 10387 Number of unique 3s: 4912 Number of unique 6s: 5426 Number of unique contradicting labels (both 3 and 6): 49 Initial number of images: 12049 Remaining non-contradicting unique images: 10338
1.4 কোয়ান্টাম সার্কিট হিসাবে ডেটা এনকোড করুন
একটি কোয়ান্টাম কম্পিউটার ব্যবহার করে ইমেজ প্রক্রিয়া করার জন্য, ফারহি এট আল। পিক্সেলের মানের উপর নির্ভর করে রাষ্ট্রের সাথে একটি qubit সহ প্রতিটি পিক্সেলের প্রতিনিধিত্ব করার প্রস্তাব করা হয়েছে। প্রথম ধাপ হল একটি বাইনারি এনকোডিং এ রূপান্তর করা।
THRESHOLD = 0.5
x_train_bin = np.array(x_train_nocon > THRESHOLD, dtype=np.float32)
x_test_bin = np.array(x_test_small > THRESHOLD, dtype=np.float32)
আপনি যদি এই মুহুর্তে বিপরীত চিত্রগুলি সরাতে চান তবে আপনার কাছে কেবল 193টি অবশিষ্ট থাকবে, সম্ভবত কার্যকর প্রশিক্ষণের জন্য যথেষ্ট নয়।
_ = remove_contradicting(x_train_bin, y_train_nocon)
Number of unique images: 193 Number of unique 3s: 80 Number of unique 6s: 69 Number of unique contradicting labels (both 3 and 6): 44 Initial number of images: 10338 Remaining non-contradicting unique images: 149
একটি থ্রেশহোল্ড অতিক্রমকারী মান সহ পিক্সেল সূচকে qubits, একটি \(X\) গেটের মাধ্যমে ঘোরানো হয়।
def convert_to_circuit(image):
"""Encode truncated classical image into quantum datapoint."""
values = np.ndarray.flatten(image)
qubits = cirq.GridQubit.rect(4, 4)
circuit = cirq.Circuit()
for i, value in enumerate(values):
if value:
circuit.append(cirq.X(qubits[i]))
return circuit
x_train_circ = [convert_to_circuit(x) for x in x_train_bin]
x_test_circ = [convert_to_circuit(x) for x in x_test_bin]
এখানে প্রথম উদাহরণের জন্য সার্কিট তৈরি করা হয়েছে (সার্কিট ডায়াগ্রাম শূন্য গেট সহ কিউবিট দেখায় না):
SVGCircuit(x_train_circ[0])
findfont: Font family ['Arial'] not found. Falling back to DejaVu Sans.
এই সার্কিটটি সূচকগুলির সাথে তুলনা করুন যেখানে চিত্রের মান থ্রেশহোল্ড অতিক্রম করে:
bin_img = x_train_bin[0,:,:,0]
indices = np.array(np.where(bin_img)).T
indices
array([[2, 2],
[3, 1]])
Tfq এর জন্য এই Cirq সার্কিটগুলিকে tfq রূপান্তর করুন:
x_train_tfcirc = tfq.convert_to_tensor(x_train_circ)
x_test_tfcirc = tfq.convert_to_tensor(x_test_circ)
2. কোয়ান্টাম নিউরাল নেটওয়ার্ক
একটি কোয়ান্টাম সার্কিট কাঠামোর জন্য সামান্য নির্দেশিকা রয়েছে যা চিত্রগুলিকে শ্রেণীবদ্ধ করে। যেহেতু শ্রেণীবিভাগটি রিডআউট কিউবিটের প্রত্যাশার উপর ভিত্তি করে, ফার্হি এট আল। দুটি কিউবিট গেট ব্যবহার করার প্রস্তাব করুন, রিডআউট কিউবিট সর্বদা কাজ করে। এটি পিক্সেল জুড়ে ছোট একটি ইউনিটারি RNN চালানোর কিছু উপায়ে অনুরূপ।
2.1 মডেল সার্কিট তৈরি করুন
এই নিম্নলিখিত উদাহরণ এই স্তরযুক্ত পদ্ধতি দেখায়. প্রতিটি স্তর একই গেটের n দৃষ্টান্ত ব্যবহার করে, প্রতিটি ডেটা কিউবিট রিডআউট কিউবিটের উপর কাজ করে।
একটি সাধারণ ক্লাস দিয়ে শুরু করুন যা একটি সার্কিটে এই গেটগুলির একটি স্তর যুক্ত করবে:
class CircuitLayerBuilder():
def __init__(self, data_qubits, readout):
self.data_qubits = data_qubits
self.readout = readout
def add_layer(self, circuit, gate, prefix):
for i, qubit in enumerate(self.data_qubits):
symbol = sympy.Symbol(prefix + '-' + str(i))
circuit.append(gate(qubit, self.readout)**symbol)
এটি দেখতে কেমন তা দেখতে একটি উদাহরণ সার্কিট স্তর তৈরি করুন:
demo_builder = CircuitLayerBuilder(data_qubits = cirq.GridQubit.rect(4,1),
readout=cirq.GridQubit(-1,-1))
circuit = cirq.Circuit()
demo_builder.add_layer(circuit, gate = cirq.XX, prefix='xx')
SVGCircuit(circuit)
এখন ডেটা-সার্কিটের আকারের সাথে মিলে একটি দ্বি-স্তরযুক্ত মডেল তৈরি করুন এবং প্রস্তুতি এবং রিডআউট অপারেশনগুলি অন্তর্ভুক্ত করুন।
def create_quantum_model():
"""Create a QNN model circuit and readout operation to go along with it."""
data_qubits = cirq.GridQubit.rect(4, 4) # a 4x4 grid.
readout = cirq.GridQubit(-1, -1) # a single qubit at [-1,-1]
circuit = cirq.Circuit()
# Prepare the readout qubit.
circuit.append(cirq.X(readout))
circuit.append(cirq.H(readout))
builder = CircuitLayerBuilder(
data_qubits = data_qubits,
readout=readout)
# Then add layers (experiment by adding more).
builder.add_layer(circuit, cirq.XX, "xx1")
builder.add_layer(circuit, cirq.ZZ, "zz1")
# Finally, prepare the readout qubit.
circuit.append(cirq.H(readout))
return circuit, cirq.Z(readout)
model_circuit, model_readout = create_quantum_model()
2.2 একটি tfq-keras মডেলে মডেল-সার্কিট মোড়ানো
কোয়ান্টাম উপাদান দিয়ে কেরাস মডেল তৈরি করুন। এই মডেলটি x_train_circ থেকে "কোয়ান্টাম ডেটা" খাওয়ানো হয়, যা ক্লাসিক্যাল ডেটা এনকোড করে। এটি কোয়ান্টাম ডেটাতে মডেল সার্কিট প্রশিক্ষণের জন্য একটি প্যারামেট্রাইজড কোয়ান্টাম সার্কিট স্তর, tfq.layers.PQC ব্যবহার করে।
এই ইমেজ শ্রেণীবদ্ধ করতে, Farhi et al. একটি প্যারামিটারাইজড সার্কিটে একটি রিডআউট কিউবিটের প্রত্যাশা নেওয়ার প্রস্তাব করা হয়েছে। প্রত্যাশা 1 এবং -1 এর মধ্যে একটি মান প্রদান করে।
# Build the Keras model.
model = tf.keras.Sequential([
# The input is the data-circuit, encoded as a tf.string
tf.keras.layers.Input(shape=(), dtype=tf.string),
# The PQC layer returns the expected value of the readout gate, range [-1,1].
tfq.layers.PQC(model_circuit, model_readout),
])
এর পরে, compile পদ্ধতি ব্যবহার করে মডেলের প্রশিক্ষণ পদ্ধতি বর্ণনা করুন।
যেহেতু প্রত্যাশিত রিডআউট পরিসরে [-1,1] , তাই কব্জা ক্ষতি অপ্টিমাইজ করা কিছুটা স্বাভাবিক মাপসই।
এখানে কব্জা ক্ষতি ব্যবহার করার জন্য আপনাকে দুটি ছোট সমন্বয় করতে হবে। প্রথমে লেবেলগুলিকে রূপান্তর করুন, y_train_nocon , বুলিয়ান থেকে [-1,1] , যেমনটি কব্জা ক্ষতি দ্বারা প্রত্যাশিত।
y_train_hinge = 2.0*y_train_nocon-1.0
y_test_hinge = 2.0*y_test-1.0
দ্বিতীয়ত, y_true লেবেল আর্গুমেন্ট হিসাবে সঠিকভাবে [-1, 1] পরিচালনা করে এমন একটি কাস্টম hinge_accuracy মেট্রিক ব্যবহার করুন। tf.losses.BinaryAccuracy(threshold=0.0) আশা করে y_true একটি বুলিয়ান হবে, এবং তাই কব্জা ক্ষতির সাথে ব্যবহার করা যাবে না)।
def hinge_accuracy(y_true, y_pred):
y_true = tf.squeeze(y_true) > 0.0
y_pred = tf.squeeze(y_pred) > 0.0
result = tf.cast(y_true == y_pred, tf.float32)
return tf.reduce_mean(result)
model.compile(
loss=tf.keras.losses.Hinge(),
optimizer=tf.keras.optimizers.Adam(),
metrics=[hinge_accuracy])
print(model.summary())
Model: "sequential"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
pqc (PQC) (None, 1) 32
=================================================================
Total params: 32
Trainable params: 32
Non-trainable params: 0
_________________________________________________________________
None
কোয়ান্টাম মডেল প্রশিক্ষণ
এখন মডেলটিকে প্রশিক্ষণ দিন—এতে প্রায় 45 মিনিট সময় লাগে। আপনি যদি এতক্ষণ অপেক্ষা করতে না চান, তাহলে ডেটার একটি ছোট উপসেট ব্যবহার করুন (নিচে NUM_EXAMPLES=500 সেট করুন)। এটি সত্যিই প্রশিক্ষণের সময় মডেলের অগ্রগতিকে প্রভাবিত করে না (এতে শুধুমাত্র 32টি পরামিতি রয়েছে এবং এগুলিকে সীমাবদ্ধ করার জন্য বেশি ডেটার প্রয়োজন নেই)। অল্প কিছু উদাহরণ ব্যবহার করলে প্রশিক্ষণটি আগে শেষ হয় (5 মিনিট), কিন্তু এটি বৈধকরণ লগগুলিতে অগ্রগতি করছে তা দেখানোর জন্য যথেষ্ট দীর্ঘ চলে।
EPOCHS = 3
BATCH_SIZE = 32
NUM_EXAMPLES = len(x_train_tfcirc)
x_train_tfcirc_sub = x_train_tfcirc[:NUM_EXAMPLES]
y_train_hinge_sub = y_train_hinge[:NUM_EXAMPLES]
এই মডেলটিকে কনভারজেন্সে প্রশিক্ষণ দিলে পরীক্ষার সেটে >85% নির্ভুলতা অর্জন করা উচিত।
qnn_history = model.fit(
x_train_tfcirc_sub, y_train_hinge_sub,
batch_size=32,
epochs=EPOCHS,
verbose=1,
validation_data=(x_test_tfcirc, y_test_hinge))
qnn_results = model.evaluate(x_test_tfcirc, y_test)
Epoch 1/3 324/324 [==============================] - 68s 207ms/step - loss: 0.6745 - hinge_accuracy: 0.7719 - val_loss: 0.3959 - val_hinge_accuracy: 0.8004 Epoch 2/3 324/324 [==============================] - 68s 209ms/step - loss: 0.3964 - hinge_accuracy: 0.8291 - val_loss: 0.3498 - val_hinge_accuracy: 0.8997 Epoch 3/3 324/324 [==============================] - 66s 204ms/step - loss: 0.3599 - hinge_accuracy: 0.8854 - val_loss: 0.3395 - val_hinge_accuracy: 0.9042 62/62 [==============================] - 3s 41ms/step - loss: 0.3395 - hinge_accuracy: 0.9042
3. ক্লাসিক্যাল নিউরাল নেটওয়ার্ক
যদিও কোয়ান্টাম নিউরাল নেটওয়ার্ক এই সরলীকৃত MNIST সমস্যার জন্য কাজ করে, একটি মৌলিক ক্লাসিক্যাল নিউরাল নেটওয়ার্ক সহজেই এই কাজটিতে একটি QNN কে ছাড়িয়ে যেতে পারে। একটি একক যুগের পরে, একটি ক্লাসিক্যাল নিউরাল নেটওয়ার্ক হোল্ডআউট সেটে >98% নির্ভুলতা অর্জন করতে পারে।
নিম্নলিখিত উদাহরণে, একটি ক্লাসিক্যাল নিউরাল নেটওয়ার্ক ব্যবহার করা হয়েছে 3-6 শ্রেণীবিভাগের সমস্যার জন্য ইমেজটির সাব-স্যাম্পল না করে পুরো 28x28 ইমেজ ব্যবহার করে। এটি সহজেই পরীক্ষা সেটের প্রায় 100% নির্ভুলতায় রূপান্তরিত হয়।
def create_classical_model():
# A simple model based off LeNet from https://keras.io/examples/mnist_cnn/
model = tf.keras.Sequential()
model.add(tf.keras.layers.Conv2D(32, [3, 3], activation='relu', input_shape=(28,28,1)))
model.add(tf.keras.layers.Conv2D(64, [3, 3], activation='relu'))
model.add(tf.keras.layers.MaxPooling2D(pool_size=(2, 2)))
model.add(tf.keras.layers.Dropout(0.25))
model.add(tf.keras.layers.Flatten())
model.add(tf.keras.layers.Dense(128, activation='relu'))
model.add(tf.keras.layers.Dropout(0.5))
model.add(tf.keras.layers.Dense(1))
return model
model = create_classical_model()
model.compile(loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
optimizer=tf.keras.optimizers.Adam(),
metrics=['accuracy'])
model.summary()
Model: "sequential_1"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
conv2d (Conv2D) (None, 26, 26, 32) 320
conv2d_1 (Conv2D) (None, 24, 24, 64) 18496
max_pooling2d (MaxPooling2D (None, 12, 12, 64) 0
)
dropout (Dropout) (None, 12, 12, 64) 0
flatten (Flatten) (None, 9216) 0
dense (Dense) (None, 128) 1179776
dropout_1 (Dropout) (None, 128) 0
dense_1 (Dense) (None, 1) 129
=================================================================
Total params: 1,198,721
Trainable params: 1,198,721
Non-trainable params: 0
_________________________________________________________________
model.fit(x_train,
y_train,
batch_size=128,
epochs=1,
verbose=1,
validation_data=(x_test, y_test))
cnn_results = model.evaluate(x_test, y_test)
95/95 [==============================] - 3s 31ms/step - loss: 0.0400 - accuracy: 0.9842 - val_loss: 0.0057 - val_accuracy: 0.9970 62/62 [==============================] - 0s 3ms/step - loss: 0.0057 - accuracy: 0.9970
উপরের মডেলে প্রায় 1.2M প্যারামিটার রয়েছে। আরও ন্যায্য তুলনার জন্য, একটি 37-প্যারামিটার মডেল চেষ্টা করুন, সাবস্যাম্পল ইমেজগুলিতে:
def create_fair_classical_model():
# A simple model based off LeNet from https://keras.io/examples/mnist_cnn/
model = tf.keras.Sequential()
model.add(tf.keras.layers.Flatten(input_shape=(4,4,1)))
model.add(tf.keras.layers.Dense(2, activation='relu'))
model.add(tf.keras.layers.Dense(1))
return model
model = create_fair_classical_model()
model.compile(loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
optimizer=tf.keras.optimizers.Adam(),
metrics=['accuracy'])
model.summary()
Model: "sequential_2"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
flatten_1 (Flatten) (None, 16) 0
dense_2 (Dense) (None, 2) 34
dense_3 (Dense) (None, 1) 3
=================================================================
Total params: 37
Trainable params: 37
Non-trainable params: 0
_________________________________________________________________
model.fit(x_train_bin,
y_train_nocon,
batch_size=128,
epochs=20,
verbose=2,
validation_data=(x_test_bin, y_test))
fair_nn_results = model.evaluate(x_test_bin, y_test)
Epoch 1/20 81/81 - 1s - loss: 0.6678 - accuracy: 0.6546 - val_loss: 0.6326 - val_accuracy: 0.7358 - 503ms/epoch - 6ms/step Epoch 2/20 81/81 - 0s - loss: 0.6186 - accuracy: 0.7654 - val_loss: 0.5787 - val_accuracy: 0.7515 - 98ms/epoch - 1ms/step Epoch 3/20 81/81 - 0s - loss: 0.5629 - accuracy: 0.7861 - val_loss: 0.5247 - val_accuracy: 0.7764 - 104ms/epoch - 1ms/step Epoch 4/20 81/81 - 0s - loss: 0.5150 - accuracy: 0.8301 - val_loss: 0.4825 - val_accuracy: 0.8196 - 103ms/epoch - 1ms/step Epoch 5/20 81/81 - 0s - loss: 0.4762 - accuracy: 0.8493 - val_loss: 0.4490 - val_accuracy: 0.8293 - 97ms/epoch - 1ms/step Epoch 6/20 81/81 - 0s - loss: 0.4438 - accuracy: 0.8527 - val_loss: 0.4216 - val_accuracy: 0.8298 - 99ms/epoch - 1ms/step Epoch 7/20 81/81 - 0s - loss: 0.4169 - accuracy: 0.8555 - val_loss: 0.3986 - val_accuracy: 0.8313 - 98ms/epoch - 1ms/step Epoch 8/20 81/81 - 0s - loss: 0.3951 - accuracy: 0.8595 - val_loss: 0.3794 - val_accuracy: 0.8313 - 105ms/epoch - 1ms/step Epoch 9/20 81/81 - 0s - loss: 0.3773 - accuracy: 0.8596 - val_loss: 0.3635 - val_accuracy: 0.8328 - 98ms/epoch - 1ms/step Epoch 10/20 81/81 - 0s - loss: 0.3620 - accuracy: 0.8611 - val_loss: 0.3499 - val_accuracy: 0.8333 - 97ms/epoch - 1ms/step Epoch 11/20 81/81 - 0s - loss: 0.3488 - accuracy: 0.8714 - val_loss: 0.3382 - val_accuracy: 0.8720 - 98ms/epoch - 1ms/step Epoch 12/20 81/81 - 0s - loss: 0.3372 - accuracy: 0.8831 - val_loss: 0.3279 - val_accuracy: 0.8720 - 95ms/epoch - 1ms/step Epoch 13/20 81/81 - 0s - loss: 0.3271 - accuracy: 0.8831 - val_loss: 0.3187 - val_accuracy: 0.8725 - 97ms/epoch - 1ms/step Epoch 14/20 81/81 - 0s - loss: 0.3181 - accuracy: 0.8832 - val_loss: 0.3107 - val_accuracy: 0.8725 - 96ms/epoch - 1ms/step Epoch 15/20 81/81 - 0s - loss: 0.3101 - accuracy: 0.8833 - val_loss: 0.3035 - val_accuracy: 0.8725 - 96ms/epoch - 1ms/step Epoch 16/20 81/81 - 0s - loss: 0.3030 - accuracy: 0.8833 - val_loss: 0.2972 - val_accuracy: 0.8725 - 105ms/epoch - 1ms/step Epoch 17/20 81/81 - 0s - loss: 0.2966 - accuracy: 0.8833 - val_loss: 0.2913 - val_accuracy: 0.8725 - 104ms/epoch - 1ms/step Epoch 18/20 81/81 - 0s - loss: 0.2908 - accuracy: 0.8928 - val_loss: 0.2861 - val_accuracy: 0.8725 - 104ms/epoch - 1ms/step Epoch 19/20 81/81 - 0s - loss: 0.2856 - accuracy: 0.8955 - val_loss: 0.2816 - val_accuracy: 0.8725 - 99ms/epoch - 1ms/step Epoch 20/20 81/81 - 0s - loss: 0.2809 - accuracy: 0.8952 - val_loss: 0.2773 - val_accuracy: 0.8725 - 101ms/epoch - 1ms/step 62/62 [==============================] - 0s 895us/step - loss: 0.2773 - accuracy: 0.8725
4. তুলনা
উচ্চতর রেজোলিউশন ইনপুট এবং আরও শক্তিশালী মডেল সিএনএন-এর জন্য এই সমস্যাটিকে সহজ করে তোলে। একই শক্তির একটি ধ্রুপদী মডেল (~32 পরামিতি) সময়ের একটি ভগ্নাংশে অনুরূপ নির্ভুলতার জন্য ট্রেন করে। একভাবে বা অন্যভাবে, ক্লাসিক্যাল নিউরাল নেটওয়ার্ক সহজেই কোয়ান্টাম নিউরাল নেটওয়ার্ককে ছাড়িয়ে যায়। ক্লাসিক্যাল ডেটার জন্য, ক্লাসিক্যাল নিউরাল নেটওয়ার্ককে হারানো কঠিন।
qnn_accuracy = qnn_results[1]
cnn_accuracy = cnn_results[1]
fair_nn_accuracy = fair_nn_results[1]
sns.barplot(["Quantum", "Classical, full", "Classical, fair"],
[qnn_accuracy, cnn_accuracy, fair_nn_accuracy])
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/seaborn/_decorators.py:43: FutureWarning: Pass the following variables as keyword args: x, y. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation. FutureWarning <AxesSubplot:>
