 TensorFlow.org'da görüntüleyin |  Google Colab'da çalıştırın |  Kaynağı GitHub'da görüntüleyin |  Not defterini indir |
Bu öğretici, Farhi ve diğerlerinde kullanılan yaklaşıma benzer şekilde, MNIST'in basitleştirilmiş bir sürümünü sınıflandırmak için bir kuantum sinir ağı (QNN) oluşturur. Kuantum sinir ağının bu klasik veri problemi üzerindeki performansı, klasik bir sinir ağı ile karşılaştırılmıştır.
Kurmak
pip install tensorflow==2.7.0
TensorFlow Quantum'u yükleyin:
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'>
Şimdi TensorFlow ve modül bağımlılıklarını içe aktarın:
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. Verileri yükleyin
Bu öğreticide, Farhi ve diğerlerini izleyerek 3 ve 6 rakamları arasında ayrım yapmak için bir ikili sınıflandırıcı oluşturacaksınız. Bu bölüm, aşağıdakileri içeren veri işlemeyi kapsar:
- Ham verileri Keras'tan yükler.
- Veri kümesini yalnızca 3s ve 6s olarak filtreler.
- Görüntülerin ölçeğini küçültür, böylece bir kuantum bilgisayara sığabilir.
- Çelişkili örnekleri kaldırır.
- İkili görüntüleri Cirq devrelerine dönüştürür.
- Cirq devrelerini TensorFlow Kuantum devrelerine dönüştürür.
1.1 Ham verileri yükleyin
Keras ile dağıtılan MNIST veri kümesini yükleyin.
(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
Yalnızca 3'leri ve 6'ları tutmak için veri kümesini filtreleyin, diğer sınıfları kaldırın. Aynı zamanda, y etiketini boolean'a dönüştürün: 3 için True ve 6 için 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
İlk örneği göster:
print(y_train[0])
plt.imshow(x_train[0, :, :, 0])
plt.colorbar()
True <matplotlib.colorbar.Colorbar at 0x7fac6ad4bd90>
1.2 Görüntüleri küçültün
28x28'lik bir görüntü boyutu, mevcut kuantum bilgisayarlar için çok fazla büyük. Resmi 4x4 olarak yeniden boyutlandırın:
x_train_small = tf.image.resize(x_train, (4,4)).numpy()
x_test_small = tf.image.resize(x_test, (4,4)).numpy()
Yeniden boyutlandırıldıktan sonra, yine ilk eğitim örneğini görüntüleyin:
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 Çelişkili örnekleri kaldırın
Farhi ve ark. , her iki sınıfa ait olarak etiketlenen görüntüleri kaldırmak için veri kümesini filtreleyin.
Bu standart bir makine öğrenimi prosedürü değildir, ancak makaleyi takip etmenin yararına dahil edilmiştir.
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)
Ortaya çıkan sayımlar, bildirilen değerlerle yakından eşleşmemektedir, ancak kesin prosedür belirtilmemiştir.
Bu noktada çelişkili örnekleri filtrelemenin uygulanmasının, modelin çelişkili eğitim örnekleri almasını tamamen engellemediğini de burada belirtmekte fayda var: sonraki adım, daha fazla çarpışmaya neden olacak verileri ikili hale getirir.
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 Verileri kuantum devreleri olarak kodlayın
Bir kuantum bilgisayar kullanarak görüntüleri işlemek için Farhi ve ark. her pikseli bir kübit ile temsil etmek, durumu pikselin değerine bağlı olarak önermek. İlk adım, ikili kodlamaya dönüştürmektir.
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)
Bu noktada çelişkili görüntüleri kaldıracak olsaydınız, yalnızca 193 ile kalacaksınız, muhtemelen etkili eğitim için yeterli değil.
_ = 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
Bir eşiği aşan değerlere sahip piksel endekslerindeki kübitler, bir \(X\) kapısı aracılığıyla döndürülür.
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]
İşte ilk örnek için oluşturulan devre (devre şemaları sıfır kapılı kübitleri göstermez):
SVGCircuit(x_train_circ[0])
findfont: Font family ['Arial'] not found. Falling back to DejaVu Sans.
Bu devreyi, görüntü değerinin eşiği aştığı dizinlerle karşılaştırın:
bin_img = x_train_bin[0,:,:,0]
indices = np.array(np.where(bin_img)).T
indices
array([[2, 2],
[3, 1]])
Bu Cirq devrelerini tfq için tensörlere dönüştürün:
x_train_tfcirc = tfq.convert_to_tensor(x_train_circ)
x_test_tfcirc = tfq.convert_to_tensor(x_test_circ)
2. Kuantum sinir ağı
Görüntüleri sınıflandıran bir kuantum devre yapısı için çok az rehberlik vardır. Sınıflandırma, okuma kübitinin beklentisine dayandığından, Farhi ve ark. okuma kübitinin her zaman etkilendiği iki kübit kapısı kullanmayı öner. Bu, bazı yönlerden pikseller arasında küçük bir Üniter RNN çalıştırmaya benzer.
2.1 Model devresini oluşturun
Aşağıdaki örnek, bu katmanlı yaklaşımı göstermektedir. Her katman, veri kübitlerinin her biri okuma kübiti üzerinde hareket ederek aynı geçidin n örneğini kullanır.
Bir devreye bu kapıların bir katmanını ekleyecek basit bir sınıfla başlayı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)
Nasıl göründüğünü görmek için örnek bir devre katmanı oluşturun:
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)
Şimdi veri devresi boyutuyla eşleşen iki katmanlı bir model oluşturun ve hazırlık ve okuma işlemlerini dahil edin.
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 Model devresini bir tfq-keras modelinde sarın
Kuantum bileşenleriyle Keras modelini oluşturun. Bu model, klasik verileri kodlayan x_train_circ "kuantum verileri" ile beslenir. Model devresini kuantum verileri üzerinde eğitmek için Parametreli Kuantum Devresi katmanını ( tfq.layers.PQC ) kullanır.
Bu görüntüleri sınıflandırmak için Farhi ve ark. parametreli bir devrede bir okuma kübiti beklentisini alarak önerildi. Beklenti, 1 ile -1 arasında bir değer döndürür.
# 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),
])
Ardından, compile yöntemini kullanarak eğitim prosedürünü modele açıklayın.
Beklenen okuma [-1,1] aralığında olduğundan, menteşe kaybını optimize etmek biraz doğal bir uyumdur.
Menteşe kaybını burada kullanmak için iki küçük ayar yapmanız gerekiyor. İlk olarak, y_train_nocon etiketlerini, menteşe kaybından beklendiği gibi boole'den [-1,1] 'e dönüştürün.
y_train_hinge = 2.0*y_train_nocon-1.0
y_test_hinge = 2.0*y_test-1.0
İkinci olarak, y_true etiketler bağımsız değişkeni olarak [-1, 1] 'i doğru şekilde işleyen bir özel hinge_accuracy metriği kullanın. tf.losses.BinaryAccuracy(threshold=0.0) , y_true bir boole olmasını bekler ve bu nedenle menteşe kaybıyla kullanılamaz).
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
Kuantum modelini eğitin
Şimdi modeli eğitin—bu yaklaşık 45 dakika sürer. Bu kadar uzun süre beklemek istemiyorsanız, verilerin küçük bir alt kümesini kullanın (aşağıda NUM_EXAMPLES=500 olarak ayarlayın). Bu, eğitim sırasında modelin ilerlemesini gerçekten etkilemez (yalnızca 32 parametresi vardır ve bunları sınırlamak için fazla veriye ihtiyaç duymaz). Daha az örnek kullanmak, eğitimi daha erken (5dk) sona erdirir, ancak doğrulama günlüklerinde ilerleme kaydettiğini gösterecek kadar uzun sürer.
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]
Bu modeli yakınsama için eğitmek, test setinde >%85 doğruluk elde etmelidir.
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. Klasik sinir ağı
Kuantum sinir ağı bu basitleştirilmiş MNIST sorunu için çalışırken, temel bir klasik sinir ağı bu görevde bir QNN'den kolayca daha iyi performans gösterebilir. Tek bir çağdan sonra, klasik bir sinir ağı, holdout setinde >%98 doğruluk elde edebilir.
Aşağıdaki örnekte, görüntüyü alt örneklemek yerine 28x28'lik görüntünün tamamını kullanan 3-6 sınıflandırma problemi için klasik bir sinir ağı kullanılmıştır. Bu, test setinin neredeyse %100 doğruluğuna kolayca yakınsar.
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
_________________________________________________________________
yer tutucu45 l10n-yermodel.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
Yukarıdaki model yaklaşık 1.2M parametreye sahiptir. Daha adil bir karşılaştırma için, alt örneklenmiş görüntülerde 37 parametreli bir model deneyin:
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
_________________________________________________________________
yer tutucu49 l10n-yermodel.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. Karşılaştırma
Daha yüksek çözünürlüklü giriş ve daha güçlü bir model, CNN için bu sorunu kolaylaştırır. Benzer güce sahip klasik bir model (~32 parametre), zamanın bir bölümünde benzer bir doğruluğa ulaşır. Öyle ya da böyle, klasik sinir ağı, kuantum sinir ağından kolayca daha iyi performans gösterir. Klasik veriler için klasik bir sinir ağını yenmek zordur.
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:>
