Qubit: You might have already heard about the term “qubit”. Comparing to a classical bit that can be at either of the two states (e.g. 0 or 1) at any time, a qubit can be at a “superposition” of both states. The state of a qubit \(|\psi\rangle\) can be expressed as:

Where \(\alpha\) and \(\beta\) are complex numbers that tell us the probabilities of measurement outcomes: If we measure the qubit, we have \(|\alpha|^2\) probability of getting \(|0\rangle\), and \(|\beta|^2\) probability of getting \(|1\rangle\) (and apparently we have \(|\alpha|^2+|\beta|^2=1\)).

So a qubit can be represented as a vector with two complex numbers:

Now we know how to describe a qubit. What about a quantum system? For a system with one or more qubits, we use state vector to describe the system’s current state. The state vector of the system is the tensor product of all qubits in it. For example, if we have a system with two qubits \(\begin{pmatrix}\alpha_1 \\ \beta_1\end{pmatrix}\) and \(\begin{pmatrix}\alpha_2 \\ \beta_2\end{pmatrix}\), its state vector is their tensor product:

If you have used Cirq (Google’s Quantum framework), you’ll notice a final_state member in simulation results – That’s the state vector of the system. You may refer to this notebook for an example usage of state vectors.

Another useful way of representing qubit is using the Bloch Sphere. Every qubit can be represented as a vector on the surface of the Bloch Sphere.

A qubit \(|\psi\rangle\) on Bloch sphere can also be written as:

Being able to get state vectors of your system is nice - it means you know everything of your system. Unfortunately this is only available in simulator. In real world, it’s usually impossible to get the state vector of your system. Instead, what you’ll get is the expectation value of your system.

Expectation value is actually a concept from probability theory. Imagine you are throwing a dice which gives you a number between 1 and 6 each time. The expectation value of your dice is the sum of all possible outcomes weighted by their probabilities. Assuming your dice is perfect (i.e. each of the 6 outcomes has equal probability), the expectation value of your dice is:

When we talk about an expectation value in quantum world, we need to specify both the state and the operator (observable).

For example, we won’t say

“Expectation value of this state vector is 0.5”

Instead, we’ll say

“Expectation value of this state vector on Z operator is 0.5”*.

Why? Because different observables will give different expectation values. As an analogy, think about projecting a vector onto an axis - choosing a different axis will give you different projection value.

So what exactly is the expectation value of a state vector on Z operator? To save your time, I’ll just write down the answer here:

• Expectation value of a state vector on Z observable is \(\cos\theta\), which is its projection on Z axis.

If you are interested, you are welcome to work out the mathematics. It’s actually pretty straightforward. :-)

We can look at a few examples to validate this conclusion:

• If current state is at “north pole” of the Bloch Sphere, we get 100% chance of getting +Z from measurements. Expectation value is \(\cos 0 = 1\).
• If current state is at “south pole” of the Bloch Sphere, we get 100% chance of getting -Z from measurements. Expectation value is \(\cos\pi = -1\).
• If current state is at point D on Bloch Sphere, we get 50% chance of getting +Z and 50% chance of -Z from measurements. Expectation value is \(\cos\frac{\pi}{2}=0\).

Things match up. Fantastic!

Our dataset includes two parts: commands and the noisy circuit.

Commands

“Commands” correpond to the target states we want our qubits to achieve. In this example, command 0 means we want the circuit to prepare a qubit at the “south pole” (\(|0\rangle\)), and command 1 means “north pole” (\(|1\rangle\)).

Noisy input

This is the circuit that emulates the noisy qubit that needs to be calibrated. TensorFlow Quantum (TFQ) provides a function tfq.convert_to_tensor to convert circuit objects from Cirq into tensors:

circuit_tensor = tfq.convert_to_tensor([circuit])

The labels are the expectation values of the target states we want our qubits to achieve. In this example, we want the qubit to be at \(|0\rangle\) (for input command 0) or \(|1\rangle\) (for input command 1). As we have seen earlier, expectation values at \(|0\rangle\) and \(|1\rangle\) are 1 and -1 respectively. Therefore our labels correspond to input commands are [1, -1].

The outputs of our hybrid model are the expectation values of the calibrated qubits.

Our model will include both classical and quantum parts.

• The classical part is the “controller” in the diagram. It’s a normal DNN, nothing special. Its outputs are the parameters (\(\theta_1\), \(\theta_2\), \(\theta_3\)) for calibration circuit.
• The quantum part is the ControllPQC layer (we’ll name it expection_layer). It takes the parameters (\(\theta_1\), \(\theta_2\), \(\theta_3\)) from controller, uses them to run the calibration circuit (model_circuit), and feeds back the outputs (expectation values) to the controller for training.

So in summary, this is what we tell our model to do:

Here is a nosiy qubit (circuit_input) and two commands (0, 1). We want you to spit out the qubit with expectation value of 1 on command 0 and expection value of -1 on command 1.

Does it make more sense now? :-)

You’ll need to install TensorFlow (2.3.1+) and TensorFlow Quantum on your computer. The easiest way is to use pip:

pip install -q tensorflow==2.3.1
pip install -q tensorflow-quantum

Import TFQ and the dependency modules:

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

First we’ll create a qubit and prepare the dataset.

# This creates a "perfect" qubit at |0>.
# It will be fed into the noisy preparation circuit to emulate a noisy qubit.
qubit = cirq.GridQubit(0, 0)

# Dataset: commands_input (0 and 1)
commands = np.array([[0], [1]], dtype=np.float32)

Create a noisy circuit with randomly generated angles, and convert it into tensor so it can be used by TensorFlow.

Note that we’ll need two copies of the circuit because we have two entries in the dataset (command 0 and command 1).

# Dataset: circuit_input (noisy preparation)
# This emulates the noisy qubit by applying X/Y/Z rotations with random angles.
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)
)

# Convert the circuit object to tensor.
# Two copies of the circuit because we have two commands (0 and 1) to train.
datapoint_circuits = tfq.convert_to_tensor([
  noisy_preparation
] * 2)

Print out the noisy circuit. We can see that the “perfect” qubit has been rotated on X, Y and Z axis with some random angles.

# Print out the noisy qubit
print(random_rotations)
print(noisy_preparation)

[3.84902356 3.3647054  3.03737137]
(0, 0): ───Rx(1.23π)───Ry(1.07π)───Rz(0.967π)───

We’ll then create the Keras input from the datasets. These will be used when we call tf.keras.Model() later.

# Create keras inputs from the datasets
circuits_input = tf.keras.Input(shape=(),
                                # The circuit-tensor has dtype `tf.string` 
                                dtype=tf.string,
                                name='circuits_input')
commands_input = tf.keras.Input(shape=(1,),
                                dtype=tf.dtypes.float32,
                                name='commands_input')

The labels are the expectation values we want for each command. In this example, we want 1 for command 0 and -1 for command 1.

# Labels: target expectation values (1 for command 0, -1 for command 1)
expected_outputs = np.array([[1], [-1]], dtype=np.float32)

Classical part of the model is a simple DNN. Since the problem is fairly small, a simple DNN with two layers will be good enough.

# Classical part of our model - "controller".
# Since the problem is fairly small, a simple DNN is enough.
controller = tf.keras.Sequential([
    tf.keras.layers.Dense(10, activation='elu'),
    tf.keras.layers.Dense(3)
])

Then the quantum part of our label. We first use the Cirq API to build our calibration circuit (``model<sub>circuit</sub>``) with three parameters (\(\theta_1\), \(\theta_2\), \(\theta_3\)).

# Quantum part of our model - "model_circuit"
# 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)

How do we incorporate this calibration circuit (model_circuit) into our model? We need to wrap it into a Keras layer so it can be connected with other layers.

In this example we’ll wrap our circuit with the “Parameterized Quantum Circuit” (PQC) layer: tfq.layers.ControlledPQC. We name it expectation_layer because it outputs the expection values.

Also note the argument operators when we create the layer: Remember that we need to specify operator when we talk about expectation value. This is how we tell PQC that we’ll take expectation values on Z operator.

After expectation_layer is created, we then connect it with the noisy circuit (circuits_input) and calibration parameters (outputs from controller, which is dense_2).

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])

We then build the model in Keras just as usual.

model = tf.keras.Model(inputs=[circuits_input, commands_input],
                       outputs=expectation)

A little visualization of our model…

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

We then train our model just like a normal DNN, using Adam as optimizer and MSE as the loss function.

# Now we can train the model...
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)

Training history shows that we are doing good…

# Plot the history - looks good!
plt.plot(history.history['loss'])
plt.title("Learning to Control a Qubit")
plt.xlabel("Iterations")
plt.ylabel("Error in Control")
plt.show()

We can verify our model by calling it with commands 0 and 1:

model([datapoint_circuits, commands])

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

As we can see, our model has calibrated the qubit into pretty well:

• On command 0, it gave expectation value of 0.98114353
• On command 1, it gave expectation value of -0.9409604

Both are very close to the target (1 and -1).

Congratulations! You have successfully trained your first Hybrid Quantum-Classical Machine Learning Model!