হ্যালো, অনেক বিশ্ব

এই টিউটোরিয়ালটি দেখায় কিভাবে একটি ক্লাসিক্যাল নিউরাল নেটওয়ার্ক কিউবিট ক্রমাঙ্কন ত্রুটিগুলি সংশোধন করতে শিখতে পারে। এটি Cirq-এর সাথে পরিচিত করে, একটি পাইথন ফ্রেমওয়ার্ক তৈরি, সম্পাদনা, এবং Noisy Intermediate Scale Quantum (NISQ) সার্কিট চালু করার জন্য, এবং প্রদর্শন করে যে কিভাবে Cirq টেনসরফ্লো কোয়ান্টামের সাথে ইন্টারফেস করে।

সেটআপ

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

# visualization tools
%matplotlib inline
import matplotlib.pyplot as plt
from cirq.contrib.svg import SVGCircuit

2022-02-04 12:27:31.677071: E tensorflow/stream_executor/cuda/cuda_driver.cc:271] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected

1. মৌলিক

1.1 Cirq এবং প্যারামিটারাইজড কোয়ান্টাম সার্কিট

TensorFlow কোয়ান্টাম (TFQ) অন্বেষণ করার আগে, আসুন কিছু Cirq বেসিক দেখুন। Cirq হল Google থেকে কোয়ান্টাম কম্পিউটিংয়ের জন্য একটি পাইথন লাইব্রেরি। আপনি স্ট্যাটিক এবং প্যারামিটারাইজড গেট সহ সার্কিট সংজ্ঞায়িত করতে এটি ব্যবহার করেন।

Cirq বিনামূল্যে পরামিতি উপস্থাপন করতে SymPy চিহ্ন ব্যবহার করে।

a, b = sympy.symbols('a b')

নিম্নলিখিত কোড আপনার পরামিতি ব্যবহার করে একটি দুই-কুবিট সার্কিট তৈরি করে:

# Create two qubits
q0, q1 = cirq.GridQubit.rect(1, 2)

# Create a circuit on these qubits using the parameters you created above.
circuit = cirq.Circuit(
    cirq.rx(a).on(q0),
    cirq.ry(b).on(q1), cirq.CNOT(control=q0, target=q1))

SVGCircuit(circuit)

findfont: Font family ['Arial'] not found. Falling back to DejaVu Sans.

সার্কিট মূল্যায়ন করতে, আপনি cirq.Simulator ইন্টারফেস ব্যবহার করতে পারেন। আপনি একটি সার্কিটে বিনামূল্যের পরামিতিগুলিকে নির্দিষ্ট সংখ্যা দিয়ে প্রতিস্থাপন করেন একটি cirq.ParamResolver অবজেক্টে পাস করে। নিম্নলিখিত কোডটি আপনার প্যারামিটারাইজড সার্কিটের কাঁচা অবস্থা ভেক্টর আউটপুট গণনা করে:

# Calculate a state vector with a=0.5 and b=-0.5.
resolver = cirq.ParamResolver({a: 0.5, b: -0.5})
output_state_vector = cirq.Simulator().simulate(circuit, resolver).final_state_vector
output_state_vector

array([ 0.9387913 +0.j        , -0.23971277+0.j        ,

        0.        +0.06120872j,  0.        -0.23971277j], dtype=complex64)

স্টেট ভেক্টরগুলি সিমুলেশনের বাইরে সরাসরি অ্যাক্সেসযোগ্য নয় (উপরের আউটপুটে জটিল সংখ্যাগুলি লক্ষ্য করুন)। শারীরিকভাবে বাস্তবসম্মত হতে, আপনাকে অবশ্যই একটি পরিমাপ নির্দিষ্ট করতে হবে, যা একটি স্টেট ভেক্টরকে একটি বাস্তব সংখ্যায় রূপান্তর করে যা ক্লাসিক্যাল কম্পিউটার বুঝতে পারে। Cirq পাউলি অপারেটর \(\hat{X}\), \(\hat{Y}\), এবং \(\hat{Z}\)এর সমন্বয় ব্যবহার করে পরিমাপ নির্দিষ্ট করে। উদাহরণ হিসাবে, নিম্নলিখিত কোডটি স্টেট ভেক্টরে l10n \(\hat{Z}_0\) এবং \(\frac{1}{2}\hat{Z}_0 + \hat{X}_1\) placeholder5 পরিমাপ করে যা আপনি এইমাত্র সিমুলেট করেছেন:

z0 = cirq.Z(q0)

qubit_map={q0: 0, q1: 1}

z0.expectation_from_state_vector(output_state_vector, qubit_map).real

0.8775825500488281

z0x1 = 0.5 * z0 + cirq.X(q1)

z0x1.expectation_from_state_vector(output_state_vector, qubit_map).real

-0.04063427448272705

1.2 টেনসর হিসাবে কোয়ান্টাম সার্কিট

TensorFlow কোয়ান্টাম (TFQ) tfq.convert_to_tensor প্রদান করে, একটি ফাংশন যা Cirq বস্তুকে টেনসরে রূপান্তর করে। এটি আপনাকে আমাদের কোয়ান্টাম স্তর এবং কোয়ান্টাম অপ্সে Cirq অবজেক্ট পাঠাতে দেয়। ফাংশনটি Cirq সার্কিট এবং Cirq Paulis-এর তালিকা বা অ্যারেতে কল করা যেতে পারে:

# Rank 1 tensor containing 1 circuit.
circuit_tensor = tfq.convert_to_tensor([circuit])

print(circuit_tensor.shape)
print(circuit_tensor.dtype)

(1,)
<dtype: 'string'>

এটি Cirq অবজেক্টগুলিকে tf.string tensors হিসাবে এনকোড করে যা tfq অপারেশনগুলি প্রয়োজন অনুসারে ডিকোড করে।

# Rank 1 tensor containing 2 Pauli operators.
pauli_tensor = tfq.convert_to_tensor([z0, z0x1])
pauli_tensor.shape

TensorShape([2])

1.3 ব্যাচিং সার্কিট সিমুলেশন

TFQ প্রত্যাশার মান, নমুনা এবং রাষ্ট্রীয় ভেক্টর গণনার পদ্ধতি প্রদান করে। আপাতত, আসুন প্রত্যাশার মানগুলিতে ফোকাস করি।

প্রত্যাশা মান গণনা করার জন্য সর্বোচ্চ-স্তরের ইন্টারফেস হল tfq.layers.Expectation স্তর, যা একটি tf.keras.Layer । এর সহজতম আকারে, এই স্তরটি অনেক সার্কিটের উপর একটি প্যারামিটারাইজড সার্কিটকে অনুকরণ করার সমতুল্য। cirq.ParamResolvers ; যাইহোক, TFQ TensorFlow শব্দার্থবিদ্যা অনুসরণ করে ব্যাচ করার অনুমতি দেয় এবং সার্কিটগুলি দক্ষ C++ কোড ব্যবহার করে সিমুলেট করা হয়।

আমাদের a এবং b পরামিতিগুলির পরিবর্তে মানগুলির একটি ব্যাচ তৈরি করুন:

batch_vals = np.array(np.random.uniform(0, 2 * np.pi, (5, 2)), dtype=np.float32)

Cirq-এ প্যারামিটার মানগুলির উপর ব্যাচিং সার্কিট সম্পাদনের জন্য একটি লুপ প্রয়োজন:

cirq_results = []
cirq_simulator = cirq.Simulator()

for vals in batch_vals:
    resolver = cirq.ParamResolver({a: vals[0], b: vals[1]})
    final_state_vector = cirq_simulator.simulate(circuit, resolver).final_state_vector
    cirq_results.append(
        [z0.expectation_from_state_vector(final_state_vector, {
            q0: 0,
            q1: 1
        }).real])

print('cirq batch results: \n {}'.format(np.array(cirq_results)))

cirq batch results: 
 [[-0.66652703]
 [ 0.49764055]
 [ 0.67326665]
 [-0.95549959]
 [-0.81297827]]

একই অপারেশন টিএফকিউতে সরলীকৃত করা হয়েছে:

tfq.layers.Expectation()(circuit,
                         symbol_names=[a, b],
                         symbol_values=batch_vals,
                         operators=z0)

<tf.Tensor: shape=(5, 1), dtype=float32, numpy=
array([[-0.666526  ],
       [ 0.49764216],
       [ 0.6732664 ],
       [-0.9554999 ],
       [-0.8129788 ]], dtype=float32)>

2. হাইব্রিড কোয়ান্টাম-ক্লাসিক্যাল অপ্টিমাইজেশান

এখন যেহেতু আপনি বেসিকগুলি দেখেছেন, আসুন একটি হাইব্রিড কোয়ান্টাম-ক্লাসিক্যাল নিউরাল নেট তৈরি করতে টেনসরফ্লো কোয়ান্টাম ব্যবহার করি। আপনি একটি একক কিউবিট নিয়ন্ত্রণ করতে একটি ক্লাসিক্যাল নিউরাল নেট প্রশিক্ষণ দেবেন। একটি সিমুলেটেড পদ্ধতিগত ক্রমাঙ্কন ত্রুটি অতিক্রম করে 0 বা 1 অবস্থায় qubit সঠিকভাবে প্রস্তুত করার জন্য নিয়ন্ত্রণটি অপ্টিমাইজ করা হবে। এই চিত্রটি স্থাপত্য দেখায়:

এমনকি একটি নিউরাল নেটওয়ার্ক ছাড়াই এটি সমাধান করার জন্য একটি সহজবোধ্য সমস্যা, কিন্তু থিমটি বাস্তব কোয়ান্টাম নিয়ন্ত্রণ সমস্যার মতো যা আপনি TFQ ব্যবহার করে সমাধান করতে পারেন। এটি tf.keras.Model এর ভিতরে tfq.layers.ControlledPQC (প্যারামেট্রিাইজড কোয়ান্টাম সার্কিট) স্তর ব্যবহার করে একটি কোয়ান্টাম-ক্লাসিক্যাল কম্পিউটেশনের এন্ড-টু-এন্ড উদাহরণ প্রদর্শন করে।

এই টিউটোরিয়ালটি বাস্তবায়নের জন্য, এই আর্কিটেকচারটি 3 ভাগে বিভক্ত:

• ইনপুট সার্কিট বা ডেটাপয়েন্ট সার্কিট : প্রথম তিনটি \(R\) গেট।
• নিয়ন্ত্রিত সার্কিট : অন্য তিনটি \(R\) গেট।
• কন্ট্রোলার : ক্লাসিক্যাল নিউরাল-নেটওয়ার্ক নিয়ন্ত্রিত সার্কিটের পরামিতি নির্ধারণ করে।

2.1 নিয়ন্ত্রিত সার্কিট সংজ্ঞা

উপরের চিত্রে নির্দেশিত হিসাবে একটি শেখারযোগ্য একক বিট ঘূর্ণন সংজ্ঞায়িত করুন। এটি আমাদের নিয়ন্ত্রিত সার্কিটের সাথে মিলে যাবে।

# Parameters that the classical NN will feed values into.
control_params = sympy.symbols('theta_1 theta_2 theta_3')

# Create the parameterized circuit.
qubit = cirq.GridQubit(0, 0)
model_circuit = cirq.Circuit(
    cirq.rz(control_params[0])(qubit),
    cirq.ry(control_params[1])(qubit),
    cirq.rx(control_params[2])(qubit))

SVGCircuit(model_circuit)

2.2 নিয়ামক

এখন কন্ট্রোলার নেটওয়ার্ক সংজ্ঞায়িত করুন:

# The classical neural network layers.
controller = tf.keras.Sequential([
    tf.keras.layers.Dense(10, activation='elu'),
    tf.keras.layers.Dense(3)
])

কমান্ডের একটি ব্যাচ দেওয়া, নিয়ন্ত্রক নিয়ন্ত্রিত সার্কিটের জন্য নিয়ন্ত্রণ সংকেতের একটি ব্যাচ আউটপুট করে।

কন্ট্রোলারটি এলোমেলোভাবে শুরু করা হয়েছে তাই এই আউটপুটগুলি এখনও কার্যকর নয়।

controller(tf.constant([[0.0],[1.0]])).numpy()

array([[0.        , 0.        , 0.        ],
       [0.5815686 , 0.21376055, 0.57181627]], dtype=float32)

2.3 সার্কিটে নিয়ামক সংযোগ করুন

নিয়ন্ত্রিত সার্কিটে নিয়ামক সংযোগ করতে tfq ব্যবহার করুন, একটি একক keras.Model হিসাবে। মডেল।

মডেল সংজ্ঞার এই শৈলী সম্পর্কে আরও জানতে কেরাস ফাংশনাল এপিআই গাইড দেখুন।

প্রথমে মডেলের ইনপুটগুলি সংজ্ঞায়িত করুন:

# This input is the simulated miscalibration that the model will learn to correct.
circuits_input = tf.keras.Input(shape=(),
                                # The circuit-tensor has dtype `tf.string` 
                                dtype=tf.string,
                                name='circuits_input')

# Commands will be either `0` or `1`, specifying the state to set the qubit to.
commands_input = tf.keras.Input(shape=(1,),
                                dtype=tf.dtypes.float32,
                                name='commands_input')

পরবর্তীতে গণনা সংজ্ঞায়িত করতে সেই ইনপুটগুলিতে ক্রিয়াকলাপ প্রয়োগ করুন।

dense_2 = controller(commands_input)

# TFQ layer for classically controlled circuits.
expectation_layer = tfq.layers.ControlledPQC(model_circuit,
                                             # Observe Z
                                             operators = cirq.Z(qubit))
expectation = expectation_layer([circuits_input, dense_2])

এখন এই গণনাটিকে একটি tf.keras.Model হিসাবে প্যাকেজ করুন:

# The full Keras model is built from our layers.
model = tf.keras.Model(inputs=[circuits_input, commands_input],
                       outputs=expectation)

নেটওয়ার্ক আর্কিটেকচার নীচের মডেলের প্লট দ্বারা নির্দেশিত হয়। সঠিকতা যাচাই করতে এই মডেল প্লটটিকে আর্কিটেকচার ডায়াগ্রামের সাথে তুলনা করুন।

দ্রষ্টব্য: graphviz প্যাকেজের একটি সিস্টেম ইনস্টল করার প্রয়োজন হতে পারে।

tf.keras.utils.plot_model(model, show_shapes=True, dpi=70)

এই মডেলটি দুটি ইনপুট নেয়: কন্ট্রোলারের জন্য কমান্ড এবং ইনপুট-সার্কিট যার আউটপুট নিয়ামক সংশোধন করার চেষ্টা করছে।

2.4 ডেটাসেট

মডেলটি প্রতিটি কমান্ডের জন্য \(\hat{Z}\) এর সঠিক সঠিক পরিমাপ মান আউটপুট করার চেষ্টা করে। কমান্ড এবং সঠিক মান নীচে সংজ্ঞায়িত করা হয়.

# The command input values to the classical NN.
commands = np.array([[0], [1]], dtype=np.float32)

# The desired Z expectation value at output of quantum circuit.
expected_outputs = np.array([[1], [-1]], dtype=np.float32)

এটি এই কাজের জন্য সম্পূর্ণ প্রশিক্ষণ ডেটাসেট নয়। ডেটাসেটের প্রতিটি ডেটাপয়েন্টেরও একটি ইনপুট সার্কিট প্রয়োজন।

2.4 ইনপুট সার্কিট সংজ্ঞা

নীচের ইনপুট-সার্কিটটি র্যান্ডম ভুল ক্যালিব্রেশনকে সংজ্ঞায়িত করে যে মডেলটি সংশোধন করতে শিখবে।

random_rotations = np.random.uniform(0, 2 * np.pi, 3)
noisy_preparation = cirq.Circuit(
  cirq.rx(random_rotations[0])(qubit),
  cirq.ry(random_rotations[1])(qubit),
  cirq.rz(random_rotations[2])(qubit)
)
datapoint_circuits = tfq.convert_to_tensor([
  noisy_preparation
] * 2)  # Make two copied of this circuit

সার্কিটের দুটি কপি রয়েছে, প্রতিটি ডেটাপয়েন্টের জন্য একটি।

datapoint_circuits.shape

TensorShape([2])

2.5 প্রশিক্ষণ

সংজ্ঞায়িত ইনপুটগুলির সাহায্যে আপনি tfq মডেলটি পরীক্ষা-চালনা করতে পারেন।

model([datapoint_circuits, commands]).numpy()

array([[0.95853525],
       [0.6272128 ]], dtype=float32)

এখন expected_outputs দিকে এই মানগুলি সামঞ্জস্য করতে একটি আদর্শ প্রশিক্ষণ প্রক্রিয়া চালান।

optimizer = tf.keras.optimizers.Adam(learning_rate=0.05)
loss = tf.keras.losses.MeanSquaredError()
model.compile(optimizer=optimizer, loss=loss)
history = model.fit(x=[datapoint_circuits, commands],
                    y=expected_outputs,
                    epochs=30,
                    verbose=0)

plt.plot(history.history['loss'])
plt.title("Learning to Control a Qubit")
plt.xlabel("Iterations")
plt.ylabel("Error in Control")
plt.show()

এই প্লট থেকে আপনি দেখতে পারেন যে নিউরাল নেটওয়ার্ক পদ্ধতিগত ভুল ক্যালিব্রেশন অতিক্রম করতে শিখেছে।

2.6 আউটপুট যাচাই করুন

এখন কিউবিট ক্রমাঙ্কন ত্রুটিগুলি সংশোধন করতে প্রশিক্ষিত মডেলটি ব্যবহার করুন। Cirq সহ:

def check_error(command_values, desired_values):
  """Based on the value in `command_value` see how well you could prepare
  the full circuit to have `desired_value` when taking expectation w.r.t. Z."""
  params_to_prepare_output = controller(command_values).numpy()
  full_circuit = noisy_preparation + model_circuit

  # Test how well you can prepare a state to get expectation the expectation
  # value in `desired_values`
  for index in [0, 1]:
    state = cirq_simulator.simulate(
        full_circuit,
        {s:v for (s,v) in zip(control_params, params_to_prepare_output[index])}
    ).final_state_vector
    expt = cirq.Z(qubit).expectation_from_state_vector(state, {qubit: 0}).real
    print(f'For a desired output (expectation) of {desired_values[index]} with'
          f' noisy preparation, the controller\nnetwork found the following '
          f'values for theta: {params_to_prepare_output[index]}\nWhich gives an'
          f' actual expectation of: {expt}\n')


check_error(commands, expected_outputs)

For a desired output (expectation) of [1.] with noisy preparation, the controller
network found the following values for theta: [-0.6788422   0.3395225  -0.59394693]
Which gives an actual expectation of: 0.9171845316886902

For a desired output (expectation) of [-1.] with noisy preparation, the controller
network found the following values for theta: [-5.203663   -0.29528576  3.2887425 ]
Which gives an actual expectation of: -0.9511058330535889

প্রশিক্ষণের সময় ক্ষতি ফাংশনের মান মডেলটি কতটা ভালভাবে শিখছে তার একটি মোটামুটি ধারণা প্রদান করে। ক্ষতি যত কম হবে, উপরের কক্ষে প্রত্যাশার মান তত কাছাকাছি হবে desired_values । আপনি যদি প্যারামিটার মানগুলির সাথে উদ্বিগ্ন না হন তবে আপনি সর্বদা tfq ব্যবহার করে উপরের থেকে আউটপুটগুলি পরীক্ষা করতে পারেন:

model([datapoint_circuits, commands])

<tf.Tensor: shape=(2, 1), dtype=float32, numpy=
array([[ 0.91718477],
       [-0.9511056 ]], dtype=float32)>

3 বিভিন্ন অপারেটরের আইজেনস্টেট প্রস্তুত করা শেখা

1 এবং 0 এর সাথে সম্পর্কিত \(\pm \hat{Z}\) eigenstates-এর পছন্দ নির্বিচারে ছিল। আপনি \(+ \hat{Z}\) \(-\hat{X}\) এর সাথে সঙ্গতিপূর্ণ করার জন্য 1কে খুব সহজে চাইতে পারেন। এটি সম্পন্ন করার একটি উপায় হল প্রতিটি কমান্ডের জন্য একটি ভিন্ন পরিমাপ অপারেটর নির্দিষ্ট করে, যেমনটি নীচের চিত্রে নির্দেশিত হয়েছে:

এর জন্য tfq.layers.Expectation ব্যবহার করা প্রয়োজন। এখন আপনার ইনপুট তিনটি বস্তু অন্তর্ভুক্ত করা হয়েছে: সার্কিট, কমান্ড এবং অপারেটর। আউটপুট এখনও প্রত্যাশা মান.

3.1 নতুন মডেল সংজ্ঞা

এই কাজটি সম্পন্ন করার জন্য মডেলটি একবার দেখে নেওয়া যাক:

# Define inputs.
commands_input = tf.keras.layers.Input(shape=(1),
                                       dtype=tf.dtypes.float32,
                                       name='commands_input')
circuits_input = tf.keras.Input(shape=(),
                                # The circuit-tensor has dtype `tf.string` 
                                dtype=tf.dtypes.string,
                                name='circuits_input')
operators_input = tf.keras.Input(shape=(1,),
                                 dtype=tf.dtypes.string,
                                 name='operators_input')

এখানে নিয়ামক নেটওয়ার্ক:

# Define classical NN.
controller = tf.keras.Sequential([
    tf.keras.layers.Dense(10, activation='elu'),
    tf.keras.layers.Dense(3)
])

সার্কিট এবং কন্ট্রোলারকে একটি একক keras.Model একত্রিত করুন। tfq ব্যবহার করে মডেল:

dense_2 = controller(commands_input)

# Since you aren't using a PQC or ControlledPQC you must append
# your model circuit onto the datapoint circuit tensor manually.
full_circuit = tfq.layers.AddCircuit()(circuits_input, append=model_circuit)
expectation_output = tfq.layers.Expectation()(full_circuit,
                                              symbol_names=control_params,
                                              symbol_values=dense_2,
                                              operators=operators_input)

# Contruct your Keras model.
two_axis_control_model = tf.keras.Model(
    inputs=[circuits_input, commands_input, operators_input],
    outputs=[expectation_output])

3.2 ডেটাসেট

এখন আপনি model_circuit জন্য সরবরাহ করা প্রতিটি ডেটাপয়েন্টের জন্য পরিমাপ করতে চান এমন অপারেটরগুলিকেও অন্তর্ভুক্ত করবেন:

# The operators to measure, for each command.
operator_data = tfq.convert_to_tensor([[cirq.X(qubit)], [cirq.Z(qubit)]])

# The command input values to the classical NN.
commands = np.array([[0], [1]], dtype=np.float32)

# The desired expectation value at output of quantum circuit.
expected_outputs = np.array([[1], [-1]], dtype=np.float32)

3.3 প্রশিক্ষণ

এখন আপনার কাছে আপনার নতুন ইনপুট এবং আউটপুট আছে আপনি কেরা ব্যবহার করে আবার প্রশিক্ষণ দিতে পারেন।

optimizer = tf.keras.optimizers.Adam(learning_rate=0.05)
loss = tf.keras.losses.MeanSquaredError()

two_axis_control_model.compile(optimizer=optimizer, loss=loss)

history = two_axis_control_model.fit(
    x=[datapoint_circuits, commands, operator_data],
    y=expected_outputs,
    epochs=30,
    verbose=1)

Epoch 1/30
1/1 [==============================] - 0s 320ms/step - loss: 2.4404
Epoch 2/30
1/1 [==============================] - 0s 3ms/step - loss: 1.8713
Epoch 3/30
1/1 [==============================] - 0s 3ms/step - loss: 1.1400
Epoch 4/30
1/1 [==============================] - 0s 3ms/step - loss: 0.5071
Epoch 5/30
1/1 [==============================] - 0s 3ms/step - loss: 0.1611
Epoch 6/30
1/1 [==============================] - 0s 3ms/step - loss: 0.0426
Epoch 7/30
1/1 [==============================] - 0s 3ms/step - loss: 0.0117
Epoch 8/30
1/1 [==============================] - 0s 3ms/step - loss: 0.0032
Epoch 9/30
1/1 [==============================] - 0s 2ms/step - loss: 0.0147
Epoch 10/30
1/1 [==============================] - 0s 3ms/step - loss: 0.0452
Epoch 11/30
1/1 [==============================] - 0s 3ms/step - loss: 0.0670
Epoch 12/30
1/1 [==============================] - 0s 3ms/step - loss: 0.0648
Epoch 13/30
1/1 [==============================] - 0s 3ms/step - loss: 0.0471
Epoch 14/30
1/1 [==============================] - 0s 3ms/step - loss: 0.0289
Epoch 15/30
1/1 [==============================] - 0s 3ms/step - loss: 0.0180
Epoch 16/30
1/1 [==============================] - 0s 3ms/step - loss: 0.0138
Epoch 17/30
1/1 [==============================] - 0s 2ms/step - loss: 0.0130
Epoch 18/30
1/1 [==============================] - 0s 3ms/step - loss: 0.0137
Epoch 19/30
1/1 [==============================] - 0s 3ms/step - loss: 0.0148
Epoch 20/30
1/1 [==============================] - 0s 3ms/step - loss: 0.0156
Epoch 21/30
1/1 [==============================] - 0s 3ms/step - loss: 0.0157
Epoch 22/30
1/1 [==============================] - 0s 3ms/step - loss: 0.0149
Epoch 23/30
1/1 [==============================] - 0s 3ms/step - loss: 0.0135
Epoch 24/30
1/1 [==============================] - 0s 3ms/step - loss: 0.0119
Epoch 25/30
1/1 [==============================] - 0s 3ms/step - loss: 0.0100
Epoch 26/30
1/1 [==============================] - 0s 3ms/step - loss: 0.0082
Epoch 27/30
1/1 [==============================] - 0s 3ms/step - loss: 0.0064
Epoch 28/30
1/1 [==============================] - 0s 3ms/step - loss: 0.0047
Epoch 29/30
1/1 [==============================] - 0s 3ms/step - loss: 0.0034
Epoch 30/30
1/1 [==============================] - 0s 3ms/step - loss: 0.0024

plt.plot(history.history['loss'])
plt.title("Learning to Control a Qubit")
plt.xlabel("Iterations")
plt.ylabel("Error in Control")
plt.show()

লস ফাংশন শূন্যে নেমে গেছে।

controller একটি স্ট্যান্ড-একা মডেল হিসাবে উপলব্ধ. নিয়ামককে কল করুন এবং প্রতিটি কমান্ড সংকেতে এর প্রতিক্রিয়া পরীক্ষা করুন। random_rotations এর বিষয়বস্তুর সাথে এই আউটপুটগুলিকে সঠিকভাবে তুলনা করতে কিছু কাজ লাগবে।

controller.predict(np.array([0,1]))

array([[3.6335812 , 1.8470774 , 0.71675825],
       [5.3085413 , 0.08116499, 2.8337662 ]], dtype=float32)

সাফল্য: আপনি এই নতুন মডেল আর্কিটেকচারের সাথে কাজ করার জন্য আপনার প্রথম মডেল থেকে check_error ফাংশন মানিয়ে নিতে পারেন কিনা দেখুন।