 TensorFlow.org पर देखें |  Google Colab में चलाएं |  GitHub पर स्रोत देखें |  नोटबुक डाउनलोड करें |
यह ट्यूटोरियल एमएनआईएसटी के सरलीकृत संस्करण को वर्गीकृत करने के लिए क्वांटम न्यूरल नेटवर्क (क्यूएनएन) बनाता है, जो फरही एट अल में उपयोग किए गए दृष्टिकोण के समान है। इस शास्त्रीय डेटा समस्या पर क्वांटम तंत्रिका नेटवर्क के प्रदर्शन की तुलना शास्त्रीय तंत्रिका नेटवर्क से की जाती है।
सेट अप
pip install tensorflow==2.7.0
TensorFlow क्वांटम स्थापित करें:
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 सर्किट को TensorFlow क्वांटम सर्किट में कनवर्ट करता है।
1.1 कच्चा डेटा लोड करें
केरस के साथ वितरित एमएनआईएसटी डेटासेट लोड करें।
(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
केवल 3 और 6 को रखने के लिए डेटासेट को फ़िल्टर करें, अन्य वर्गों को हटा दें। उसी समय, 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>प्लेसहोल्डर17
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
थ्रेशोल्ड से अधिक मान वाले पिक्सेल इंडेक्स पर क्वैबिट्स को \(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.प्लेसहोल्डर26
इस सर्किट की तुलना उन सूचकांकों से करें जहाँ छवि मान दहलीज से अधिक है:
bin_img = x_train_bin[0,:,:,0]
indices = np.array(np.where(bin_img)).T
indices
array([[2, 2],
[3, 1]])
tfq के लिए इन Cirq सर्किट को टेंसर में बदलें:
x_train_tfcirc = tfq.convert_to_tensor(x_train_circ)
x_test_tfcirc = tfq.convert_to_tensor(x_test_circ)
2. क्वांटम तंत्रिका नेटवर्क
छवियों को वर्गीकृत करने वाली क्वांटम सर्किट संरचना के लिए बहुत कम मार्गदर्शन है। चूंकि वर्गीकरण रीडआउट क्वेट, फरही एट अल की अपेक्षा पर आधारित है। दो qubit गेट्स का उपयोग करने का प्रस्ताव, जिसमें रीडआउट qubit हमेशा कार्य करता है। यह कुछ मायनों में पिक्सेल में छोटे एकात्मक आरएनएन को चलाने के समान है।
2.1 मॉडल सर्किट बनाएँ
यह निम्नलिखित उदाहरण इस स्तरित दृष्टिकोण को दर्शाता है। प्रत्येक परत एक ही गेट के n उदाहरणों का उपयोग करती है, प्रत्येक डेटा qubit रीडआउट qubit पर कार्य करता है।
एक साधारण वर्ग से शुरू करें जो इन फाटकों की एक परत को एक सर्किट में जोड़ देगा:
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 का उपयोग करता है।
इन छवियों को वर्गीकृत करने के लिए, फरही एट अल। एक पैरामीटरयुक्त सर्किट में रीडआउट क्वबिट की अपेक्षा लेने का प्रस्ताव है। उम्मीद 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
दूसरा, एक कस्टम hinge_accuracy मीट्रिक का उपयोग करें जो y_true लेबल तर्क के रूप में [-1, 1] को सही ढंग से संभालता है। 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:>
