سر و صدا

مشاهده در TensorFlow.org در Google Colab اجرا شود مشاهده منبع در GitHub دانلود دفترچه یادداشت

نویز در کامپیوترهای کوانتومی امروزی وجود دارد. کیوبیت در معرض تداخل امواج از محیط اطراف، ساخت ناقص، TLS و گاهی حتی می اشعه گاما . تا زمانی که به تصحیح خطا در مقیاس بزرگ دست یابیم، الگوریتم های امروزی باید بتوانند در حضور نویز کارایی خود را حفظ کنند. این امر باعث می‌شود آزمایش الگوریتم‌ها تحت نویز گام مهمی برای اعتبارسنجی الگوریتم‌های کوانتومی باشد/مدل‌ها در رایانه‌های کوانتومی امروزی کار خواهند کرد.

در این آموزش شما را به اصول اولیه شبیه سازی مدار پر سر و صدا در TFQ از طریق سطح بالا کشف tfq.layers API.

برپایی

pip install tensorflow==2.4.1 tensorflow-quantum

pip install -q git+https://github.com/tensorflow/docs

# 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'>

import random
import cirq
import sympy
import tensorflow_quantum as tfq
import tensorflow as tf
import numpy as np
# Plotting
import matplotlib.pyplot as plt
import tensorflow_docs as tfdocs
import tensorflow_docs.plots

2021-10-12 11:23:10.079578: E tensorflow/stream_executor/cuda/cuda_driver.cc:328] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected

1. درک نویز کوانتومی

1.1 نویز پایه مدار

نویز در یک کامپیوتر کوانتومی بر نمونه‌های رشته بیتی که می‌توانید از آن اندازه‌گیری کنید، تأثیر می‌گذارد. یکی از راه‌های شهودی که می‌توانید درباره این موضوع فکر کنید این است که یک کامپیوتر کوانتومی پر سر و صدا دروازه‌ها را در مکان‌های تصادفی مانند نمودار زیر «درج»، «حذف» یا «جایگزین» می‌کند:

ساختمان را از این شهود، در هنگام برخورد با سر و صدا، شما دیگر با استفاده از یک خالص دولت \(|\psi \rangle\) اما در عوض با یک مجموعه از تمام تحقق پر سر و صدا ممکن است از مدار مورد نظر خود را خرید و فروش: \(\rho = \sum_j p_j |\psi_j \rangle \langle \psi_j |\) . که در آن \(p_j\) احتمال می دهد که سیستم در است \(|\psi_j \rangle\) .

با مشاهده مجدد تصویر بالا، اگر از قبل می دانستیم که 90٪ مواقع سیستم ما به خوبی اجرا می شود، یا 10٪ از مواقع فقط با همین یک حالت خرابی خطا می کند، آنگاه مجموعه ما اینگونه خواهد بود:

\(\rho = 0.9 |\psi_\text{desired} \rangle \langle \psi_\text{desired}| + 0.1 |\psi_\text{noisy} \rangle \langle \psi_\text{noisy}| \)

اگر بیش از یک راه است که مدار ما می تواند خطا وجود دارد، پس از آن گروه \(\rho\) بیش از فقط دو دوره (یکی برای هر تحقق پر سر و صدا جدید است که می تواند رخ دهد) باشد. \(\rho\) است به عنوان مراجعه کننده ماتریس چگالی توصیف سیستم پر سر و صدا خود را.

1.2 استفاده از کانال ها برای مدل سازی نویز مدار

متأسفانه در عمل تقریباً غیرممکن است که همه راه هایی که مدار شما ممکن است خطا کند و احتمالات دقیق آنها را بدانید. یک فرض ساده شما می توانید مطمئن است که پس از هر عملیات در مدار خود نوعی از وجود دارد کانال که تقریبا قطاری که عملیات ممکن خطا. می توانید به سرعت یک مدار با مقداری نویز ایجاد کنید:

def x_circuit(qubits):
  """Produces an X wall circuit on `qubits`."""
  return cirq.Circuit(cirq.X.on_each(*qubits))

def make_noisy(circuit, p):
  """Add a depolarization channel to all qubits in `circuit` before measurement."""
  return circuit + cirq.Circuit(cirq.depolarize(p).on_each(*circuit.all_qubits()))

my_qubits = cirq.GridQubit.rect(1, 2)
my_circuit = x_circuit(my_qubits)
my_noisy_circuit = make_noisy(my_circuit, 0.5)
my_circuit

my_noisy_circuit

شما می توانید بی صدا ماتریس چگالی بررسی \(\rho\) با:

rho = cirq.final_density_matrix(my_circuit)
np.round(rho, 3)

array([[0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
       [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
       [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
       [0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j]], dtype=complex64)

و پر سر و صدا ماتریس چگالی \(\rho\) با:

rho = cirq.final_density_matrix(my_noisy_circuit)
np.round(rho, 3)

array([[0.111+0.j, 0.   +0.j, 0.   +0.j, 0.   +0.j],
       [0.   +0.j, 0.222+0.j, 0.   +0.j, 0.   +0.j],
       [0.   +0.j, 0.   +0.j, 0.222+0.j, 0.   +0.j],
       [0.   +0.j, 0.   +0.j, 0.   +0.j, 0.444+0.j]], dtype=complex64)

مقایسه دو مختلف \( \rho \) را به شما می توانید ببینید که سر و صدا دامنه از دولت (و احتمالات نمونه برداری در نتیجه) نهفته است. در مورد بی صدا شما همیشه انتظار می رود به نمونه \( |11\rangle \) دولت است. اما در حالت پر سر و صدا در حال حاضر یک احتمال غیر صفر از نمونه برداری وجود دارد \( |00\rangle \) یا \( |01\rangle \) یا \( |10\rangle \) و همچنین:

"""Sample from my_noisy_circuit."""
def plot_samples(circuit):
  samples = cirq.sample(circuit + cirq.measure(*circuit.all_qubits(), key='bits'), repetitions=1000)
  freqs, _ = np.histogram(samples.data['bits'], bins=[i+0.01 for i in range(-1,2** len(my_qubits))])
  plt.figure(figsize=(10,5))
  plt.title('Noisy Circuit Sampling')
  plt.xlabel('Bitstring')
  plt.ylabel('Frequency')
  plt.bar([i for i in range(2** len(my_qubits))], freqs, tick_label=['00','01','10','11'])

plot_samples(my_noisy_circuit)

png

بدون هیچ گونه سر و صدا شما همیشه می خواهد \(|11\rangle\):

"""Sample from my_circuit."""
plot_samples(my_circuit)

png

اگر شما سر و صدا افزایش کمی بیشتر آن را تبدیل به سخت تر و سخت تر به تشخیص رفتار مورد نظر (نمونه برداری \(|11\rangle\) ) از سر و صدا:

my_really_noisy_circuit = make_noisy(my_circuit, 0.75)
plot_samples(my_really_noisy_circuit)

png

2. نویز اصلی در TFQ

با این درک از اینکه نویز چگونه می تواند بر اجرای مدار تأثیر بگذارد، می توانید نحوه عملکرد نویز در TFQ را بررسی کنید. TensorFlow Quantum از شبیه سازی مونت کارلو/مسیر به عنوان جایگزینی برای شبیه سازی ماتریس چگالی استفاده می کند. این به این دلیل است که پیچیدگی حافظه شبیه‌سازی ماتریس چگالی، شبیه‌سازی‌های بزرگ را به کمتر از 20 کیوبیت با روش‌های شبیه‌سازی ماتریس با چگالی کامل سنتی محدود می‌کند. مونت کارلو / مسیر این هزینه را در حافظه با هزینه اضافی در زمان مبادله می کند. backend='noisy' گزینه موجود برای تمام tfq.layers.Sample ، tfq.layers.SampledExpectation و tfq.layers.Expectation (در مورد Expectation این اضافه کردن مورد نیاز repetitions پارامتر).

2.1 نمونه برداری پر سر و صدا در TFQ

برای از نو خلق توطئه بالا با استفاده از TFQ و مسیر شبیه سازی شما می توانید استفاده کنید tfq.layers.Sample

"""Draw bitstring samples from `my_noisy_circuit`"""
bitstrings = tfq.layers.Sample(backend='noisy')(my_noisy_circuit, repetitions=1000)

numeric_values = np.einsum('ijk,k->ij', bitstrings.to_tensor().numpy(), [1, 2])[0]
freqs, _ = np.histogram(numeric_values, bins=[i+0.01 for i in range(-1,2** len(my_qubits))])
plt.figure(figsize=(10,5))
plt.title('Noisy Circuit Sampling')
plt.xlabel('Bitstring')
plt.ylabel('Frequency')
plt.bar([i for i in range(2** len(my_qubits))], freqs, tick_label=['00','01','10','11'])

<BarContainer object of 4 artists>

png

2.2 انتظار بر اساس نمونه پر سر و صدا

برای این کار پر سر و صدا نمونه محاسبه انتظار بر اساس شما می توانید استفاده tfq.layers.SampleExpectation :

some_observables = [cirq.X(my_qubits[0]), cirq.Z(my_qubits[0]), 3.0 * cirq.Y(my_qubits[1]) + 1]
some_observables

[cirq.X(cirq.GridQubit(0, 0)),
 cirq.Z(cirq.GridQubit(0, 0)),
 cirq.PauliSum(cirq.LinearDict({frozenset({(cirq.GridQubit(0, 1), cirq.Y)}): (3+0j), frozenset(): (1+0j)}))]

برآوردهای انتظارات بدون صدا را از طریق نمونه برداری از مدار محاسبه کنید:

noiseless_sampled_expectation = tfq.layers.SampledExpectation(backend='noiseless')(
    my_circuit, operators=some_observables, repetitions=10000
)
noiseless_sampled_expectation.numpy()

array([[ 0.0076, -1.    ,  0.9796]], dtype=float32)

آنها را با نسخه های نویز مقایسه کنید:

noisy_sampled_expectation = tfq.layers.SampledExpectation(backend='noisy')(
    [my_noisy_circuit, my_really_noisy_circuit], operators=some_observables, repetitions=10000
)
noisy_sampled_expectation.numpy()

array([[ 0.0208    , -0.32099998,  1.0731999 ],
       [-0.0126    ,  0.0062    ,  1.012     ]], dtype=float32)

شما می توانید ببینید که سر و صدا شده است به خصوص تأثیر را \(\langle \psi | Z | \psi \rangle\) دقت، با my_really_noisy_circuit تمرکز بسیار به سرعت به سمت 0.

2.3 محاسبه انتظارات تحلیلی پر سر و صدا

انجام محاسبات انتظارات تحلیلی پر سر و صدا تقریباً مشابه موارد فوق است:

noiseless_analytic_expectation = tfq.layers.Expectation(backend='noiseless')(
    my_circuit, operators=some_observables
)
noiseless_analytic_expectation.numpy()

array([[ 1.9106853e-15, -1.0000000e+00,  1.0000002e+00]], dtype=float32)

noisy_analytic_expectation = tfq.layers.Expectation(backend='noisy')(
    [my_noisy_circuit, my_really_noisy_circuit], operators=some_observables, repetitions=10000
)
noisy_analytic_expectation.numpy()

array([[ 1.9106853e-15, -3.2819998e-01,  1.0000000e+00],
       [ 1.9106855e-15,  1.3200002e-02,  1.0000000e+00]], dtype=float32)

3. مدل های ترکیبی و نویز داده های کوانتومی

اکنون که برخی شبیه‌سازی‌های مدار نویزدار را در TFQ پیاده‌سازی کرده‌اید، می‌توانید با مقایسه و مقایسه عملکرد نویز و بی‌صدا آنها، نحوه تأثیر نویز بر مدل‌های کلاسیک کوانتومی کوانتومی و ترکیبی را آزمایش کنید. اولین بررسی خوب برای اینکه ببینیم آیا یک مدل یا الگوریتم در برابر نویز مقاوم است یا خیر این است که تحت یک مدل دپلاریزاسیون گسترده مدار آزمایش کنیم که چیزی شبیه به این است:

جایی که هر برش زمانی از مدار (گاهی اوقات به عنوان لحظه از آن یاد می‌شود) پس از هر عملیات گیت در آن برش زمانی، یک کانال دپلاریزاسیون اضافه می‌شود. کانال depolarizing با یکی از اعمال \(\{X, Y, Z \}\) با احتمال \(p\) یا درخواست چیزی (نگه داشتن عملیات اصلی) با احتمال \(1-p\).

3.1 داده ها

برای این مثال، شما می توانید مدارهای آماده در استفاده tfq.datasets ماژول را به عنوان داده های آموزشی:

qubits = cirq.GridQubit.rect(1, 8)
circuits, labels, pauli_sums, _ = tfq.datasets.xxz_chain(qubits, 'closed')
circuits[0]

Downloading data from https://storage.googleapis.com/download.tensorflow.org/data/quantum/spin_systems/XXZ_chain.zip 
184451072/184449737 [==============================] - 1s 0us/step

نوشتن یک تابع کمکی کوچک به تولید داده‌ها برای کیس پر سر و صدا و بدون نویز کمک می‌کند:

def get_data(qubits, depolarize_p=0.):
  """Return quantum data circuits and labels in `tf.Tensor` form."""
  circuits, labels, pauli_sums, _ = tfq.datasets.xxz_chain(qubits, 'closed')
  if depolarize_p >= 1e-5:
    circuits = [circuit.with_noise(cirq.depolarize(depolarize_p)) for circuit in circuits]
  tmp = list(zip(circuits, labels))
  random.shuffle(tmp)
  circuits_tensor = tfq.convert_to_tensor([x[0] for x in tmp])
  labels_tensor = tf.convert_to_tensor([x[1] for x in tmp])

  return circuits_tensor, labels_tensor

3.2 یک مدار مدل را تعریف کنید

اکنون که داده‌های کوانتومی به شکل مدار دارید، برای مدل‌سازی این داده‌ها به یک مدار نیاز دارید، مانند داده‌ها می‌توانید یک تابع کمکی بنویسید تا این مدار به صورت اختیاری حاوی نویز باشد:

def modelling_circuit(qubits, depth, depolarize_p=0.):
  """A simple classifier circuit."""
  dim = len(qubits)
  ret = cirq.Circuit(cirq.H.on_each(*qubits))

  for i in range(depth):
    # Entangle layer.
    ret += cirq.Circuit(cirq.CX(q1, q2) for (q1, q2) in zip(qubits[::2], qubits[1::2]))
    ret += cirq.Circuit(cirq.CX(q1, q2) for (q1, q2) in zip(qubits[1::2], qubits[2::2]))
    # Learnable rotation layer.
    # i_params = sympy.symbols(f'layer-{i}-0:{dim}')
    param = sympy.Symbol(f'layer-{i}')
    single_qb = cirq.X
    if i % 2 == 1:
      single_qb = cirq.Y
    ret += cirq.Circuit(single_qb(q) ** param for q in qubits)

  if depolarize_p >= 1e-5:
    ret = ret.with_noise(cirq.depolarize(depolarize_p))

  return ret, [op(q) for q in qubits for op in [cirq.X, cirq.Y, cirq.Z]]

modelling_circuit(qubits, 3)[0]

3.3 ساخت و آموزش مدل

با داده های خود و مدار مدل ساخته شده است، تابع کمکی نهایی شما نیاز است که می تواند هر دو پر سر و صدا و یا یک کوانتوم هیبریدی بی صدا جمع آوری است tf.keras.Model :

def build_keras_model(qubits, depolarize_p=0.):
  """Prepare a noisy hybrid quantum classical Keras model."""
  spin_input = tf.keras.Input(shape=(), dtype=tf.dtypes.string)

  circuit_and_readout = modelling_circuit(qubits, 4, depolarize_p)
  if depolarize_p >= 1e-5:
    quantum_model = tfq.layers.NoisyPQC(*circuit_and_readout, sample_based=False, repetitions=10)(spin_input)
  else:
    quantum_model = tfq.layers.PQC(*circuit_and_readout)(spin_input)

  intermediate = tf.keras.layers.Dense(4, activation='sigmoid')(quantum_model)
  post_process = tf.keras.layers.Dense(1)(intermediate)

  return tf.keras.Model(inputs=[spin_input], outputs=[post_process])

4. مقایسه عملکرد

4.1 خط پایه بدون صدا

با تولید داده و کد ساخت مدل خود، اکنون می توانید عملکرد مدل را در تنظیمات بدون نویز و نویز مقایسه و مقایسه کنید، ابتدا می توانید یک آموزش بی صدا مرجع را اجرا کنید:

training_histories = dict()
depolarize_p = 0.
n_epochs = 50
phase_classifier = build_keras_model(qubits, depolarize_p)

phase_classifier.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.02),
                   loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
                   metrics=['accuracy'])


# Show the keras plot of the model
tf.keras.utils.plot_model(phase_classifier, show_shapes=True, dpi=70)

png

noiseless_data, noiseless_labels = get_data(qubits, depolarize_p)
training_histories['noiseless'] = phase_classifier.fit(x=noiseless_data,
                         y=noiseless_labels,
                         batch_size=16,
                         epochs=n_epochs,
                         validation_split=0.15,
                         verbose=1)

Epoch 1/50
4/4 [==============================] - 1s 218ms/step - loss: 0.7061 - accuracy: 0.5354 - val_loss: 0.6503 - val_accuracy: 0.6667
Epoch 2/50
4/4 [==============================] - 0s 86ms/step - loss: 0.6802 - accuracy: 0.5396 - val_loss: 0.6689 - val_accuracy: 0.6667
Epoch 3/50
4/4 [==============================] - 0s 83ms/step - loss: 0.6861 - accuracy: 0.4500 - val_loss: 0.6975 - val_accuracy: 0.6667
Epoch 4/50
4/4 [==============================] - 0s 82ms/step - loss: 0.6710 - accuracy: 0.4417 - val_loss: 0.7223 - val_accuracy: 0.6667
Epoch 5/50
4/4 [==============================] - 0s 82ms/step - loss: 0.6695 - accuracy: 0.4729 - val_loss: 0.7348 - val_accuracy: 0.6667
Epoch 6/50
4/4 [==============================] - 0s 80ms/step - loss: 0.6526 - accuracy: 0.6146 - val_loss: 0.7379 - val_accuracy: 0.9167
Epoch 7/50
4/4 [==============================] - 0s 80ms/step - loss: 0.6480 - accuracy: 0.7875 - val_loss: 0.7291 - val_accuracy: 1.0000
Epoch 8/50
4/4 [==============================] - 0s 80ms/step - loss: 0.6365 - accuracy: 0.7771 - val_loss: 0.7116 - val_accuracy: 1.0000
Epoch 9/50
4/4 [==============================] - 0s 78ms/step - loss: 0.6311 - accuracy: 0.7521 - val_loss: 0.6915 - val_accuracy: 0.9167
Epoch 10/50
4/4 [==============================] - 0s 79ms/step - loss: 0.6081 - accuracy: 0.7000 - val_loss: 0.6706 - val_accuracy: 0.9167
Epoch 11/50
4/4 [==============================] - 0s 86ms/step - loss: 0.6163 - accuracy: 0.6771 - val_loss: 0.6395 - val_accuracy: 0.8333
Epoch 12/50
4/4 [==============================] - 0s 83ms/step - loss: 0.5897 - accuracy: 0.6500 - val_loss: 0.6194 - val_accuracy: 0.8333
Epoch 13/50
4/4 [==============================] - 1s 148ms/step - loss: 0.5791 - accuracy: 0.6708 - val_loss: 0.6012 - val_accuracy: 0.9167
Epoch 14/50
4/4 [==============================] - 0s 83ms/step - loss: 0.5650 - accuracy: 0.6396 - val_loss: 0.5838 - val_accuracy: 0.9167
Epoch 15/50
4/4 [==============================] - 0s 87ms/step - loss: 0.5702 - accuracy: 0.7167 - val_loss: 0.5576 - val_accuracy: 0.9167
Epoch 16/50
4/4 [==============================] - 0s 89ms/step - loss: 0.5475 - accuracy: 0.6750 - val_loss: 0.5391 - val_accuracy: 1.0000
Epoch 17/50
4/4 [==============================] - 0s 84ms/step - loss: 0.5346 - accuracy: 0.7146 - val_loss: 0.5167 - val_accuracy: 1.0000
Epoch 18/50
4/4 [==============================] - 0s 92ms/step - loss: 0.5329 - accuracy: 0.7812 - val_loss: 0.4905 - val_accuracy: 1.0000
Epoch 19/50
4/4 [==============================] - 0s 90ms/step - loss: 0.4863 - accuracy: 0.7708 - val_loss: 0.4731 - val_accuracy: 1.0000
Epoch 20/50
4/4 [==============================] - 0s 88ms/step - loss: 0.4724 - accuracy: 0.7875 - val_loss: 0.4549 - val_accuracy: 1.0000
Epoch 21/50
4/4 [==============================] - 0s 94ms/step - loss: 0.4780 - accuracy: 0.8396 - val_loss: 0.4301 - val_accuracy: 1.0000
Epoch 22/50
4/4 [==============================] - 0s 85ms/step - loss: 0.4446 - accuracy: 0.8375 - val_loss: 0.4101 - val_accuracy: 1.0000
Epoch 23/50
4/4 [==============================] - 0s 92ms/step - loss: 0.4458 - accuracy: 0.8396 - val_loss: 0.3863 - val_accuracy: 1.0000
Epoch 24/50
4/4 [==============================] - 0s 93ms/step - loss: 0.4097 - accuracy: 0.8750 - val_loss: 0.3616 - val_accuracy: 1.0000
Epoch 25/50
4/4 [==============================] - 0s 89ms/step - loss: 0.3907 - accuracy: 0.8750 - val_loss: 0.3410 - val_accuracy: 1.0000
Epoch 26/50
4/4 [==============================] - 0s 91ms/step - loss: 0.3842 - accuracy: 0.8646 - val_loss: 0.3180 - val_accuracy: 1.0000
Epoch 27/50
4/4 [==============================] - 0s 90ms/step - loss: 0.3509 - accuracy: 0.9062 - val_loss: 0.2951 - val_accuracy: 1.0000
Epoch 28/50
4/4 [==============================] - 0s 91ms/step - loss: 0.3495 - accuracy: 0.8688 - val_loss: 0.2813 - val_accuracy: 1.0000
Epoch 29/50
4/4 [==============================] - 0s 94ms/step - loss: 0.3393 - accuracy: 0.8917 - val_loss: 0.2606 - val_accuracy: 1.0000
Epoch 30/50
4/4 [==============================] - 0s 92ms/step - loss: 0.3277 - accuracy: 0.8750 - val_loss: 0.2449 - val_accuracy: 1.0000
Epoch 31/50
4/4 [==============================] - 0s 90ms/step - loss: 0.2935 - accuracy: 0.9292 - val_loss: 0.2331 - val_accuracy: 1.0000
Epoch 32/50
4/4 [==============================] - 0s 91ms/step - loss: 0.2875 - accuracy: 0.9229 - val_loss: 0.2188 - val_accuracy: 1.0000
Epoch 33/50
4/4 [==============================] - 0s 94ms/step - loss: 0.2820 - accuracy: 0.9354 - val_loss: 0.2049 - val_accuracy: 1.0000
Epoch 34/50
4/4 [==============================] - 0s 93ms/step - loss: 0.2705 - accuracy: 0.8958 - val_loss: 0.1957 - val_accuracy: 1.0000
Epoch 35/50
4/4 [==============================] - 0s 91ms/step - loss: 0.2499 - accuracy: 0.9500 - val_loss: 0.1832 - val_accuracy: 1.0000
Epoch 36/50
4/4 [==============================] - 0s 92ms/step - loss: 0.2445 - accuracy: 0.9354 - val_loss: 0.1705 - val_accuracy: 1.0000
Epoch 37/50
4/4 [==============================] - 0s 90ms/step - loss: 0.2533 - accuracy: 0.9437 - val_loss: 0.1623 - val_accuracy: 1.0000
Epoch 38/50
4/4 [==============================] - 0s 96ms/step - loss: 0.2253 - accuracy: 0.9542 - val_loss: 0.1525 - val_accuracy: 1.0000
Epoch 39/50
4/4 [==============================] - 0s 89ms/step - loss: 0.2189 - accuracy: 0.9646 - val_loss: 0.1425 - val_accuracy: 1.0000
Epoch 40/50
4/4 [==============================] - 0s 95ms/step - loss: 0.2273 - accuracy: 0.9417 - val_loss: 0.1372 - val_accuracy: 1.0000
Epoch 41/50
4/4 [==============================] - 0s 85ms/step - loss: 0.2346 - accuracy: 0.9437 - val_loss: 0.1325 - val_accuracy: 1.0000
Epoch 42/50
4/4 [==============================] - 0s 96ms/step - loss: 0.2227 - accuracy: 0.9479 - val_loss: 0.1235 - val_accuracy: 1.0000
Epoch 43/50
4/4 [==============================] - 1s 149ms/step - loss: 0.2134 - accuracy: 0.9437 - val_loss: 0.1192 - val_accuracy: 1.0000
Epoch 44/50
4/4 [==============================] - 0s 85ms/step - loss: 0.2066 - accuracy: 0.9250 - val_loss: 0.1149 - val_accuracy: 1.0000
Epoch 45/50
4/4 [==============================] - 0s 83ms/step - loss: 0.2168 - accuracy: 0.9375 - val_loss: 0.1095 - val_accuracy: 1.0000
Epoch 46/50
4/4 [==============================] - 0s 84ms/step - loss: 0.1759 - accuracy: 0.9604 - val_loss: 0.1053 - val_accuracy: 1.0000
Epoch 47/50
4/4 [==============================] - 0s 81ms/step - loss: 0.1850 - accuracy: 0.9833 - val_loss: 0.0980 - val_accuracy: 1.0000
Epoch 48/50
4/4 [==============================] - 0s 81ms/step - loss: 0.1910 - accuracy: 0.9479 - val_loss: 0.0913 - val_accuracy: 1.0000
Epoch 49/50
4/4 [==============================] - 0s 80ms/step - loss: 0.1698 - accuracy: 0.9250 - val_loss: 0.0911 - val_accuracy: 1.0000
Epoch 50/50
4/4 [==============================] - 0s 83ms/step - loss: 0.1698 - accuracy: 0.9542 - val_loss: 0.0855 - val_accuracy: 1.0000

و نتایج و دقت را بررسی کنید:

loss_plotter = tfdocs.plots.HistoryPlotter(metric = 'loss', smoothing_std=10)
loss_plotter.plot(training_histories)

png

acc_plotter = tfdocs.plots.HistoryPlotter(metric = 'accuracy', smoothing_std=10)
acc_plotter.plot(training_histories)

png

4.2 مقایسه پر سر و صدا

اکنون می توانید یک مدل جدید با ساختار نویز بسازید و با موارد بالا مقایسه کنید، کد تقریباً یکسان است:

depolarize_p = 0.001
n_epochs = 50
noisy_phase_classifier = build_keras_model(qubits, depolarize_p)

noisy_phase_classifier.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.02),
                   loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
                   metrics=['accuracy'])


# Show the keras plot of the model
tf.keras.utils.plot_model(noisy_phase_classifier, show_shapes=True, dpi=70)

png

noisy_data, noisy_labels = get_data(qubits, depolarize_p)
training_histories['noisy'] = noisy_phase_classifier.fit(x=noisy_data,
                         y=noisy_labels,
                         batch_size=16,
                         epochs=n_epochs,
                         validation_split=0.15,
                         verbose=1)

Epoch 1/50
4/4 [==============================] - 8s 2s/step - loss: 0.6710 - accuracy: 0.3771 - val_loss: 0.8007 - val_accuracy: 0.7500
Epoch 2/50
4/4 [==============================] - 7s 2s/step - loss: 0.6745 - accuracy: 0.4271 - val_loss: 0.7787 - val_accuracy: 0.7500
Epoch 3/50
4/4 [==============================] - 7s 2s/step - loss: 0.6698 - accuracy: 0.4354 - val_loss: 0.7603 - val_accuracy: 0.7500
Epoch 4/50
4/4 [==============================] - 7s 2s/step - loss: 0.6528 - accuracy: 0.4083 - val_loss: 0.7550 - val_accuracy: 0.7500
Epoch 5/50
4/4 [==============================] - 7s 2s/step - loss: 0.6535 - accuracy: 0.4313 - val_loss: 0.7370 - val_accuracy: 0.8333
Epoch 6/50
4/4 [==============================] - 7s 2s/step - loss: 0.6445 - accuracy: 0.4979 - val_loss: 0.7201 - val_accuracy: 0.8333
Epoch 7/50
4/4 [==============================] - 7s 2s/step - loss: 0.6333 - accuracy: 0.4917 - val_loss: 0.7185 - val_accuracy: 0.8333
Epoch 8/50
4/4 [==============================] - 7s 2s/step - loss: 0.6152 - accuracy: 0.5854 - val_loss: 0.6988 - val_accuracy: 0.9167
Epoch 9/50
4/4 [==============================] - 7s 2s/step - loss: 0.5806 - accuracy: 0.6562 - val_loss: 0.6805 - val_accuracy: 0.9167
Epoch 10/50
4/4 [==============================] - 7s 2s/step - loss: 0.5872 - accuracy: 0.6854 - val_loss: 0.6599 - val_accuracy: 0.9167
Epoch 11/50
4/4 [==============================] - 7s 2s/step - loss: 0.5753 - accuracy: 0.7875 - val_loss: 0.6401 - val_accuracy: 0.9167
Epoch 12/50
4/4 [==============================] - 7s 2s/step - loss: 0.5682 - accuracy: 0.8354 - val_loss: 0.6097 - val_accuracy: 0.9167
Epoch 13/50
4/4 [==============================] - 7s 2s/step - loss: 0.5380 - accuracy: 0.8396 - val_loss: 0.5732 - val_accuracy: 0.9167
Epoch 14/50
4/4 [==============================] - 7s 2s/step - loss: 0.5061 - accuracy: 0.7708 - val_loss: 0.5657 - val_accuracy: 0.9167
Epoch 15/50
4/4 [==============================] - 7s 2s/step - loss: 0.5043 - accuracy: 0.8604 - val_loss: 0.5254 - val_accuracy: 1.0000
Epoch 16/50
4/4 [==============================] - 7s 2s/step - loss: 0.4795 - accuracy: 0.8708 - val_loss: 0.4805 - val_accuracy: 1.0000
Epoch 17/50
4/4 [==============================] - 7s 2s/step - loss: 0.4456 - accuracy: 0.8000 - val_loss: 0.4539 - val_accuracy: 1.0000
Epoch 18/50
4/4 [==============================] - 7s 2s/step - loss: 0.4512 - accuracy: 0.9021 - val_loss: 0.4331 - val_accuracy: 1.0000
Epoch 19/50
4/4 [==============================] - 7s 2s/step - loss: 0.4210 - accuracy: 0.8688 - val_loss: 0.4411 - val_accuracy: 1.0000
Epoch 20/50
4/4 [==============================] - 7s 2s/step - loss: 0.4167 - accuracy: 0.8646 - val_loss: 0.3781 - val_accuracy: 0.9167
Epoch 21/50
4/4 [==============================] - 7s 2s/step - loss: 0.3550 - accuracy: 0.9375 - val_loss: 0.3492 - val_accuracy: 1.0000
Epoch 22/50
4/4 [==============================] - 7s 2s/step - loss: 0.3720 - accuracy: 0.9000 - val_loss: 0.3550 - val_accuracy: 1.0000
Epoch 23/50
4/4 [==============================] - 7s 2s/step - loss: 0.3251 - accuracy: 0.9292 - val_loss: 0.3234 - val_accuracy: 1.0000
Epoch 24/50
4/4 [==============================] - 7s 2s/step - loss: 0.3264 - accuracy: 0.9333 - val_loss: 0.2942 - val_accuracy: 1.0000
Epoch 25/50
4/4 [==============================] - 7s 2s/step - loss: 0.2937 - accuracy: 0.9125 - val_loss: 0.3439 - val_accuracy: 0.9167
Epoch 26/50
4/4 [==============================] - 7s 2s/step - loss: 0.2798 - accuracy: 0.9250 - val_loss: 0.2842 - val_accuracy: 1.0000
Epoch 27/50
4/4 [==============================] - 7s 2s/step - loss: 0.2835 - accuracy: 0.9479 - val_loss: 0.2385 - val_accuracy: 1.0000
Epoch 28/50
4/4 [==============================] - 7s 2s/step - loss: 0.2610 - accuracy: 0.9417 - val_loss: 0.2352 - val_accuracy: 1.0000
Epoch 29/50
4/4 [==============================] - 7s 2s/step - loss: 0.2916 - accuracy: 0.8875 - val_loss: 0.2221 - val_accuracy: 1.0000
Epoch 30/50
4/4 [==============================] - 7s 2s/step - loss: 0.2620 - accuracy: 0.9417 - val_loss: 0.2054 - val_accuracy: 1.0000
Epoch 31/50
4/4 [==============================] - 7s 2s/step - loss: 0.2015 - accuracy: 0.9417 - val_loss: 0.2074 - val_accuracy: 1.0000
Epoch 32/50
4/4 [==============================] - 7s 2s/step - loss: 0.2462 - accuracy: 0.9292 - val_loss: 0.1961 - val_accuracy: 1.0000
Epoch 33/50
4/4 [==============================] - 7s 2s/step - loss: 0.2042 - accuracy: 0.9938 - val_loss: 0.1820 - val_accuracy: 1.0000
Epoch 34/50
4/4 [==============================] - 7s 2s/step - loss: 0.1951 - accuracy: 0.9667 - val_loss: 0.1748 - val_accuracy: 1.0000
Epoch 35/50
4/4 [==============================] - 7s 2s/step - loss: 0.2175 - accuracy: 0.9271 - val_loss: 0.1628 - val_accuracy: 1.0000
Epoch 36/50
4/4 [==============================] - 7s 2s/step - loss: 0.1792 - accuracy: 0.9563 - val_loss: 0.1569 - val_accuracy: 1.0000
Epoch 37/50
4/4 [==============================] - 7s 2s/step - loss: 0.1809 - accuracy: 0.9229 - val_loss: 0.1613 - val_accuracy: 1.0000
Epoch 38/50
4/4 [==============================] - 7s 2s/step - loss: 0.1747 - accuracy: 0.9313 - val_loss: 0.1622 - val_accuracy: 1.0000
Epoch 39/50
4/4 [==============================] - 7s 2s/step - loss: 0.1588 - accuracy: 1.0000 - val_loss: 0.1483 - val_accuracy: 1.0000
Epoch 40/50
4/4 [==============================] - 7s 2s/step - loss: 0.1709 - accuracy: 0.9437 - val_loss: 0.1428 - val_accuracy: 1.0000
Epoch 41/50
4/4 [==============================] - 7s 2s/step - loss: 0.1743 - accuracy: 0.9563 - val_loss: 0.1420 - val_accuracy: 0.9167
Epoch 42/50
4/4 [==============================] - 7s 2s/step - loss: 0.2167 - accuracy: 0.9021 - val_loss: 0.1526 - val_accuracy: 1.0000
Epoch 43/50
4/4 [==============================] - 7s 2s/step - loss: 0.1694 - accuracy: 0.9271 - val_loss: 0.1315 - val_accuracy: 1.0000
Epoch 44/50
4/4 [==============================] - 7s 2s/step - loss: 0.1597 - accuracy: 0.9646 - val_loss: 0.1601 - val_accuracy: 0.9167
Epoch 45/50
4/4 [==============================] - 7s 2s/step - loss: 0.1764 - accuracy: 0.9437 - val_loss: 0.1094 - val_accuracy: 1.0000
Epoch 46/50
4/4 [==============================] - 7s 2s/step - loss: 0.1582 - accuracy: 0.9542 - val_loss: 0.1403 - val_accuracy: 1.0000
Epoch 47/50
4/4 [==============================] - 7s 2s/step - loss: 0.1879 - accuracy: 0.9542 - val_loss: 0.0674 - val_accuracy: 1.0000
Epoch 48/50
4/4 [==============================] - 7s 2s/step - loss: 0.1812 - accuracy: 0.9708 - val_loss: 0.0751 - val_accuracy: 1.0000
Epoch 49/50
4/4 [==============================] - 7s 2s/step - loss: 0.1231 - accuracy: 0.9875 - val_loss: 0.1512 - val_accuracy: 1.0000
Epoch 50/50
4/4 [==============================] - 7s 2s/step - loss: 0.1537 - accuracy: 0.9292 - val_loss: 0.0958 - val_accuracy: 1.0000

loss_plotter.plot(training_histories)

png

acc_plotter.plot(training_histories)

png