def color_svg(circuit: cirq.Circuit, *coords: Tuple[int, int]) -> Any:
"""
color cirq circuit SVG for given gates
:param circuit:
:param coords: integer coordinate which gate is colored
:return:
"""
import xml
svg_str = SVGCircuit(circuit)._repr_svg_()
DOMTree = xml.dom.minidom.parseString(svg_str) # type: ignore
xpos = []
ypos = []
for r in DOMTree.getElementsByTagName("rect"): # [0].setAttribute("fill", "gray")
xpos.append(int(float(r.getAttribute("x"))))
ypos.append(int(float(r.getAttribute("y"))))
xpos = sorted(list(set(xpos)))
ypos = sorted(list(set(ypos)))
# xpos_dict = dict(zip(range(len(xpos)), xpos))
# ypos_dict = dict(zip(range(len(ypos)), ypos))
i_xpos_dict = dict(zip(xpos, range(len(xpos))))
i_ypos_dict = dict(zip(ypos, range(len(ypos))))
for r in DOMTree.getElementsByTagName("rect"):
x, y = int(float(r.getAttribute("x"))), int(float(r.getAttribute("y")))
if (i_xpos_dict[x], i_ypos_dict[y]) in coords:
r.setAttribute("fill", "gray")
return DOMTree.toxml()
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)
def main():
"""Demonstrates Quantum Fourier transform.
"""
# Create circuit
qft_circuit = generate_2x2_grid_qft_circuit()
SVGCircuit(qft_circuit)
print('Circuit:')
print(qft_circuit)
# Simulate and collect final_state
simulator = cirq.Simulator()
result = simulator.simulate(qft_circuit)
print()
print('FinalState')
print(np.around(result.final_state, 3))
def svg(self):
"""Get the SVG circuit (for visualization)"""
return SVGCircuit(self)
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])
bin_img = x_train_bin[0, :, :, 0]
indices = np.array(np.where(bin_img)).T
indices
x_train_tfcirc = tfq.convert_to_tensor(x_train_circ)
x_test_tfcirc = tfq.convert_to_tensor(x_test_circ)
class CircuitLayerBuilder():
def __init__(self, data_qubits, readout):
self.data_qubits = data_qubits
self.readout = readout
def add_layer(self, circuit, gate, prefix):
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt
from cirq.contrib.svg import SVGCircuit
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)
# 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
z0 = cirq.Z(q0)
qubit_map = {q0: 0, q1: 1}
z0.expectation_from_state_vector(output_state_vector, qubit_map).real
z0x1 = 0.5 * z0 + cirq.X(q1)
def start():
print("starting...")
# 1. Laden Sie die Daten
# 1.1 Laden Sie die Rohdaten
(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))
print("filter...")
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))
print(y_train[0])
plt.imshow(x_train[0, :, :, 0])
plt.colorbar()
# save image
# 1.2 Verkleinern Sie die Bilder
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()
# save image
# 1.3 Entfernen Sie widersprüchliche Beispiele
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)
# 1.4 Codieren Sie die Daten als Quantenschaltungen
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)
_ = remove_contradicting(x_train_bin, y_train_nocon)
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])
bin_img = x_test_bin[0, :, :, 0]
indices = np.array(np.where(bin_img)).T
print(f"Indices: {indices}")
x_train_tfcirc = tfq.convert_to_tensor(x_train_circ)
x_test_tfcirc = tfq.convert_to_tensor(x_test_circ)
# 2. Quantenneurales Netzwerk
# 2.1 Erstellen Sie die Modellschaltung
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)
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 Wickeln Sie die Modellschaltung in ein tfq-keras-Modell
# 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),
])
y_train_hinge = 2.0 * y_train_nocon - 1.0
y_test_hinge = 2.0 * y_test - 1.0
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())
# Training of the QNN
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]
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)
# 3. Klassisches neuronales Netzwerk
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.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)
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.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)
# 4. Vergleich
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],
)
circuit = cirq.Circuit()
for i in range(4):
circuit += cirq.rx(symb[i])(q[i])
circuit += cirq.rz(symb[i])(q[i])
for l in range(nl):
for i in range(3):
circuit.append(cirq.CNOT(q[i], q[i + 1]))
for i in range(4):
print(W[l][i][0])
circuit += cirq.rz(W[l][i][0])(q[i])
circuit += cirq.ry(W[l][i][1])(q[i])
circuit += cirq.rz(W[l][i][2])(q[i])
op = cirq.Z(q[0]), cirq.Z(q[1]), cirq.Z(q[2]), cirq.Z(q[3])
print(SVGCircuit(circuit))
class VQC(Model):
def __init__(self):
super(VQC, self).__init__()
self.step = 0
self.TARGET_UPDATE = 20
self.optimizer = tf.keras.optimizers.SGD(lr=0.5)
self.W = tf.Variable(np.random.rand(3 * nq * nl))
self.bias = tf.Variable(np.zeros(4), dtype='float32')
self.oW = tf.Variable(self.W.initialized_value(), trainable=0)
self.obias = tf.Variable(self.bias.initialized_value(),
dtype='float32',
trainable=0)
circuit += cirq.rx(symbols[l][i][1])(qubit)
circuit += cirq.rz(symbols[l][i][2])(qubit)
circuit += cirq.CZ(qubits[0], qubits[1])
circuit += cirq.CZ(qubits[2], qubits[3])
circuit += cirq.CZ(qubits[1], qubits[2])
op = 1 / 4 * (cirq.X(qubits[0]) + cirq.X(qubits[1]) + cirq.X(qubits[2]) +
cirq.X(qubits[3]))
return circuit, op, list(symb)
nr_of_qubits = 4
layers = 2
tf_circuit, op, (symbols) = generate_circuit(nr_of_qubits, layers)
SVGCircuit(tf_circuit)
# ### Training
#
# One can leverage all the Tensorflow machinery for training quantum circuits. We will now insert the previous circuit in a ``tf.keras`` model in order to train it.
#
# First of all, the circuit must be converted into a layer so it can be inserted in a model. The most direct choice is the ``PQC`` (which stands for Parameterized Quantum Circuit) layer. This layer requires as additional specifications the operator we are going to measure in the end, the number of evaluations, and the way the gradients are going to be computed.
# In[3]:
outputs = tfq.layers.PQC(
tf_circuit, # Circuit to be transformed into tf layer
1 - op)
# Next, we can instantiate a model, taking an arbitrary input and outputting the result of the measurement of $M$
import cirq
import sympy
import numpy as np
#%matplotlib inline
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt
from cirq.contrib.svg import SVGCircuit
qubit = cirq.GridQubit(0, 0)
my_circuit = cirq.Circuit(cirq.Y(qubit)**sympy.Symbol('alpha'))
SVGCircuit(my_circuit)
pauli_x = cirq.X(qubit)
pauli_x
def my_expectation(op, alpha):
"""Compute ⟨Y(alpha)| `op` | Y(alpha)⟩"""
params = {'alpha': alpha}
sim = cirq.Simulator()
final_state_vector = sim.simulate(my_circuit, params).final_state_vector
return op.expectation_from_state_vector(final_state_vector, {
qubit: 0
}).real
return tfq.convert_to_tensor(train_excitations), np.array(train_labels), \
tfq.convert_to_tensor(test_excitations), np.array(test_labels)
sample_points, sample_labels, _, __ = generate_data(cirq.GridQubit.rect(1, 4))
print('Input:', tfq.from_tensor(sample_points)[0], 'Output:', sample_labels[0])
print('Input:', tfq.from_tensor(sample_points)[1], 'Output:', sample_labels[1])
def cluster_state_circuit(bits):
"""Return a cluster state on the qubits in `bits`."""
circuit = cirq.Circuit()
circuit.append(cirq.H.on_each(bits))
for this_bit, next_bit in zip(bits, bits[1:] + [bits[0]]):
circuit.append(cirq.CZ(this_bit, next_bit))
return circuit
SVGCircuit(cluster_state_circuit(cirq.GridQubit.rect(1, 4)))
def one_qubit_unitary(bit, symbols):
"""Make a Cirq circuit enacting a rotation of the bloch sphere about the X,
Y and Z axis, that depends on the values in `symbols`.
"""
return cirq.Circuit(
cirq.X(bit)**symbols[0],
cirq.Y(bit)**symbols[1],
cirq.Z(bit)**symbols[2])
def two_qubit_unitary(bits, symbols):
"""Make a Cirq circuit that creates an arbitrary two qubit unitary."""
circuit = cirq.Circuit()
circuit += one_qubit_unitary(bits[0], symbols[0:3])
# visualization tools
%matplotlib inline
import matplotlib.pyplot as plt
from cirq.contrib.svg import SVGCircuit
a, b = sympy.symbols('a b')
# ２qubits circuit
q0, q1 = cirq.GridQubit.rect(1, 2)
# rx gate on q0 with parameter a, and ry gate on q1 with parameter b
circuit = cirq.Circuit(
cirq.rx(a).on(q0),
cirq.ry(b).on(q1), cirq.CNOT(control=q0, target=q1))
SVGCircuit(circuit)
# state vector at a=0.5, b=-0.5
resolver = cirq.ParamResolver({a: 0.5, b: -0.5})
output_state_vector = cirq.Simulator().simulate(circuit, resolver).final_state
output_state_vector
#gets an array([ 0.9387913 +0.j , -0.23971277+0.j , 0. +0.06120872j, 0. -0.23971277j], dtype=complex64)
z0 = cirq.Z(q0)
qubit_map={q0: 0, q1: 1}
z0.expectation_from_wavefunction(output_state_vector, qubit_map).real
