مساعدة في حماية الحاجز المرجاني العظيم مع TensorFlow على Kaggle تاريخ التحدي

تصنيف MNIST

عرض على TensorFlow.org تشغيل في Google Colab عرض المصدر على جيثب تحميل دفتر

ويستند هذا البرنامج التعليمي الكم الشبكة العصبية (QNN) لتصنيف نسخة مبسطة من MNIST، على غرار النهج المتبع في فرحي وآخرون . تتم مقارنة أداء الشبكة العصبية الكمومية في مشكلة البيانات الكلاسيكية هذه مع الشبكة العصبية الكلاسيكية.

اقامة

pip install tensorflow==2.4.1

تثبيت TensorFlow Quantum:

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
2021-10-12 11:17:38.992283: E tensorflow/stream_executor/cuda/cuda_driver.cc:328] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected

1. تحميل البيانات

في هذا البرنامج التعليمي سوف بناء المصنف ثنائي للتمييز بين الأرقام 3 و 6، بعد فرحي وآخرون. يغطي هذا القسم معالجة البيانات التي:

  • يقوم بتحميل البيانات الأولية من Keras.
  • لتصفية مجموعة البيانات إلى 3 ثوانٍ و 6 ثوانٍ فقط.
  • يعمل على تصغير حجم الصور بحيث يمكن وضعها في جهاز كمبيوتر كمي.
  • يزيل أي أمثلة متناقضة.
  • يحول الصور الثنائية إلى دوائر Cirq.
  • يحول دوائر Cirq إلى دوائر الكم TensorFlow.

1.1 تحميل البيانات الأولية

قم بتحميل مجموعة بيانات MNIST الموزعة مع Keras.

(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
Number of original training examples: 60000
Number of original test examples: 10000

قم بتصفية مجموعة البيانات للاحتفاظ بـ 3s و 6s فقط ، وإزالة الفئات الأخرى. في الوقت نفسه تحويل التسمية، y ، أن قيمة المنطقية: True ل 3 و False لمدة 6.

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 0x7f2c5f779b50>

بي إن جي

1.2 تصغير الصور

حجم الصورة 28 × 28 كبير جدًا بالنسبة لأجهزة الكمبيوتر الكمومية الحالية. تغيير حجم الصورة إلى 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 0x7f2a580afc50>

بي إن جي

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 تشفير البيانات كدوائر كمومية

لمعالجة الصور باستخدام جهاز كمبيوتر الكم، فرحي وآخرون. اقترح تمثيل كل بكسل مع كيوبت ، مع اعتماد الحالة على قيمة البكسل. الخطوة الأولى هي التحويل إلى تشفير ثنائي.

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.

svg

قارن هذه الدائرة بالمؤشرات حيث تتجاوز قيمة الصورة العتبة:

bin_img = x_train_bin[0,:,:,0]
indices = np.array(np.where(bin_img)).T
indices
array([[2, 2],
       [3, 1]])

تحويل هذه Cirq الدوائر إلى التنسورات ل tfq :

x_train_tfcirc = tfq.convert_to_tensor(x_train_circ)
x_test_tfcirc = tfq.convert_to_tensor(x_test_circ)

2. الشبكة العصبية الكمومية

هناك القليل من الإرشادات المتعلقة بهيكل الدائرة الكمومية الذي يصنف الصور. منذ يستند التصنيف على التوقعات للو qubit قراءات، فرحي وآخرون. اقترح استخدام بوابتين كيوبت ، مع العمل دائمًا على قراءة كيوبت. هذا هو مماثل في بعض الطرق لتشغيل صغير موحدة RNN عبر بكسل.

2.1 بناء نموذج الدائرة

يوضح هذا المثال التالي هذا النهج متعدد الطبقات. كل الاستخدامات طبقة ن حالات من البوابة نفسها، مع كل من المكدسة البيانات بناء على قراءات و 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)

svg

الآن قم ببناء نموذج من طبقتين ، يطابق حجم دائرة البيانات ، ويتضمن عمليات التحضير والقراءة.

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

بناء نموذج Keras مع المكونات الكمومية. ويتم تغذية هذا النموذج "بيانات الكم"، من x_train_circ ، الذي يشفر البيانات الكلاسيكية. ويستخدم طبقة Parametrized الكم الدائرة، 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

ثانيا، استخدام custiom hinge_accuracy متري أن بشكل صحيح مقابض [-1, 1] كما y_true حجة العلامات. 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 [==============================] - 75s 231ms/step - loss: 0.9057 - hinge_accuracy: 0.6409 - val_loss: 0.4408 - val_hinge_accuracy: 0.8004
Epoch 2/3
324/324 [==============================] - 70s 217ms/step - loss: 0.4020 - hinge_accuracy: 0.8427 - val_loss: 0.3718 - val_hinge_accuracy: 0.9017
Epoch 3/3
324/324 [==============================] - 75s 233ms/step - loss: 0.3673 - hinge_accuracy: 0.8769 - val_loss: 0.3499 - val_hinge_accuracy: 0.9042
62/62 [==============================] - 3s 43ms/step - loss: 0.3499 - hinge_accuracy: 0.9042

3. الشبكة العصبية الكلاسيكية

بينما تعمل الشبكة العصبية الكمومية لحل مشكلة MNIST المبسطة ، يمكن للشبكة العصبية الكلاسيكية الأساسية أن تتفوق بسهولة على QNN في هذه المهمة. بعد حقبة واحدة ، يمكن للشبكة العصبية الكلاسيكية تحقيق> 98 ٪ من الدقة في مجموعة الانتظار.

في المثال التالي ، يتم استخدام الشبكة العصبية الكلاسيكية لمشكلة التصنيف 3-6 باستخدام صورة 28 × 28 بأكملها بدلاً من أخذ عينات فرعية للصورة. يتقارب هذا بسهولة إلى ما يقرب من 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.1101 - accuracy: 0.9512 - val_loss: 0.0043 - val_accuracy: 0.9990
62/62 [==============================] - 0s 3ms/step - loss: 0.0043 - accuracy: 0.9990

النموذج أعلاه لديه ما يقرب من 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.6826 - accuracy: 0.5249 - val_loss: 0.6673 - val_accuracy: 0.4868
Epoch 2/20
81/81 - 0s - loss: 0.6531 - accuracy: 0.5249 - val_loss: 0.6177 - val_accuracy: 0.4873
Epoch 3/20
81/81 - 0s - loss: 0.5791 - accuracy: 0.5680 - val_loss: 0.5300 - val_accuracy: 0.6184
Epoch 4/20
81/81 - 0s - loss: 0.4693 - accuracy: 0.7562 - val_loss: 0.4142 - val_accuracy: 0.7983
Epoch 5/20
81/81 - 0s - loss: 0.3809 - accuracy: 0.8301 - val_loss: 0.3464 - val_accuracy: 0.8140
Epoch 6/20
81/81 - 0s - loss: 0.3275 - accuracy: 0.8450 - val_loss: 0.3046 - val_accuracy: 0.8267
Epoch 7/20
81/81 - 0s - loss: 0.2945 - accuracy: 0.8544 - val_loss: 0.2793 - val_accuracy: 0.8262
Epoch 8/20
81/81 - 0s - loss: 0.2735 - accuracy: 0.8551 - val_loss: 0.2624 - val_accuracy: 0.8262
Epoch 9/20
81/81 - 0s - loss: 0.2591 - accuracy: 0.8555 - val_loss: 0.2504 - val_accuracy: 0.8262
Epoch 10/20
81/81 - 0s - loss: 0.2490 - accuracy: 0.8565 - val_loss: 0.2420 - val_accuracy: 0.8277
Epoch 11/20
81/81 - 0s - loss: 0.2418 - accuracy: 0.8586 - val_loss: 0.2359 - val_accuracy: 0.8664
Epoch 12/20
81/81 - 0s - loss: 0.2366 - accuracy: 0.8780 - val_loss: 0.2316 - val_accuracy: 0.8674
Epoch 13/20
81/81 - 0s - loss: 0.2328 - accuracy: 0.8791 - val_loss: 0.2280 - val_accuracy: 0.9141
Epoch 14/20
81/81 - 0s - loss: 0.2299 - accuracy: 0.9033 - val_loss: 0.2257 - val_accuracy: 0.9141
Epoch 15/20
81/81 - 0s - loss: 0.2276 - accuracy: 0.9035 - val_loss: 0.2240 - val_accuracy: 0.9151
Epoch 16/20
81/81 - 0s - loss: 0.2260 - accuracy: 0.9015 - val_loss: 0.2223 - val_accuracy: 0.9157
Epoch 17/20
81/81 - 0s - loss: 0.2246 - accuracy: 0.9037 - val_loss: 0.2209 - val_accuracy: 0.9157
Epoch 18/20
81/81 - 0s - loss: 0.2235 - accuracy: 0.9037 - val_loss: 0.2199 - val_accuracy: 0.9157
Epoch 19/20
81/81 - 0s - loss: 0.2226 - accuracy: 0.9037 - val_loss: 0.2192 - val_accuracy: 0.9157
Epoch 20/20
81/81 - 0s - loss: 0.2218 - accuracy: 0.9037 - val_loss: 0.2184 - val_accuracy: 0.9157
62/62 [==============================] - 0s 611us/step - loss: 0.2184 - accuracy: 0.9157

4. المقارنة

تجعل المدخلات عالية الدقة والنموذج الأكثر قوة هذه المشكلة سهلة لشبكة CNN. بينما يتدرب النموذج الكلاسيكي لقوة مماثلة (~ 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])
/home/kbuilder/.local/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:>

بي إن جي