INTRODUCTION On March 9, 2020, Google AI confirmed the availability of TensorFlow Quantum (TFQ), an open-source library for rapid prototyping of quantum machine learning models. Earlier there were several other frameworks like Pennylane, but none of them were as fantastic as TFQ. TensorFlow Quantum comes as a toolbox in this field that was not available till yet. I've read and understood a couple of other frameworks, but after researching the TFQ, there's no denying that the TFQ is best. Let's continue to understand how we can design a quantum neural network using TensorFlow Quantum. How can we do Machine learning over parameterized quantum circuits? To grasp this explicitly, there is an example provided by Masoud Mohseni (Tech lead of TensorFlow Quantum). And, he said, "We need to note that when you print this kind of unit operations or random rotations in the space-time volume that you have, this is a kind of continuous parameterized rotation that mimics classical circuits like deep neural networks that map those inputs to outputs." This is the explanation behind the word Quantum Neural Networks. But how do we create these parameterized quantum circuits? The first step in developing hybrid quantum models is to be able to exploit quantum operations. To do so, TensorFlow Quantum depends on Cirq, an open-source platform for implementing quantum circuits on near-term computers. Cirq includes fundamental structures, such as qubits, gates, circuits and calculation operators, which are needed to define quantum computations. The concept behind the Cirq is to  to provide a simple programming model that abstracts the fundamental building blocks of quantum applications. If you really want to learn more about quantum computation and cirq implementation, you can read my article . here Can we combine cirq and TensorFlow Quantum, and what are the challenges for that? Technical Hurdle 1 Quantum data can not be imported. Quantum data must be prepared on the fly. Both data and the model are layers in the quantum circuit. Technical Hurdle 2 QPU needs full quantum program for each run. QPU run in few microseconds. Relatively high latency CPU-QPU. Batches of jobs are relayed to the quantum computer. Tensorflow Quantum Team is coming up with certain incridible architecture concepts in the programming background to make it practical and conquer the hurdles. The architecture criteria are laid out below. Must support differentiation of quantum circuits and hybrid backpropagation. Differentiability: Quantum data loaded as quantum circuits, Training over many different circuits in parallel. Circuit batching: Switch from a simulator to real device easily with few changes. Execution Backend Agnostic: Does not require a user to relearn how to interface with the quantum computer to solve the problems using machine learning. Minimalism: A bridge between Cirq and TF: Step by step execution TFQ pipeline for hybrid discriminative model Step 1: Prepare a quantum dataset: the quantum data is loaded as a tensor, defined as a quantum circuit written in Cirq. The tensor is executed by TensorFlow on the quantum computer to generate a quantum dataset. Quantum datasets are prepared using unparameterized objects and are injected into the computational graph using cirq.Circuit tfq.convert_to_tensor Step 2: Evaluate a quantum neural network model: In this step, the researcher can prototype a quantum neural network using Cirq that they will later embed inside of a TensorFlow compute graph. Quantum models are constructed using objects containing SymPy symbols,and can be attached to quantum data sources using the layer. cirq.Circuit tfq.AddCircuit Step 3: Sample or Average: This step leverages methods for averaging over several runs involving steps (1) and (2). Sampling or averaging are performed by feeding quantum data and quantum models to the or layers. tfq.Sample tfq.Expectation Step 4: Evaluate a classical neural networks model: This step uses classical deep neural networks to distil such correlations between the measures extracted in the previous steps. Since TFQ is fully compatible withcore TensorFlow, quantum models can be attached directly to classical objects such as tf.keras.layers.Dense. tf.keras.layers.Layer Step 5: Evaluate Cost Function: Similar to traditional machine learning models, TFQ uses this step to evaluate a cost function. This could be based on how accurately the model performs the classification task if the quantum data was labelled, or other criteria if the task is unsupervised. Wrapping the model built in stages (1)through (4) inside a gives the user access to all the losses in the module. tf.keras.Model tf.keras.losses Step 6: Evaluate Gradients & Update Parameters — After evaluating the cost function, the free parameters in the pipeline should be updated in a direction expected to decrease the cost. To support gradient descent, TFQ exposes derivatives of quantum operations to the TensorFlow backpropagation machinery via the . This allows both the quantum and classical models parameters to be optimized against quantum data via hybrid quantum-classical backpropagation tfq.differentiators.Differentiatorinterface Coding demo !pip install --upgrade cirq== !pip install --upgrade tensorflow== !pip install qutip
!pip install tensorflow-quantum cirq numpy np qutip random sympy tensorflow tf tensorflow_quantum tfq q_data = []
  bloch = { : [[], [], []], : [[], [], []]}
  labels = []
  blob_size = abs(theta_a - theta_b) / _ range(num_samples):
    coin = random.random()
    spread_x = np.random.uniform(-blob_size, blob_size)
    spread_y = np.random.uniform(-blob_size, blob_size) coin < :
      label = [ , ]
      angle = theta_a + spread_y
      source = :
      label = [ , ]
      angle = theta_b + spread_y
      source = labels.append(label)
    q_data.append(cirq.Circuit(cirq.ry(-angle)(qubit), cirq.rx(-spread_x)(qubit)))
    bloch[source][ ].append(np.cos(angle))
    bloch[source][ ].append(np.sin(angle)*np.sin(spread_x))
    bloch[source][ ].append(np.sin(angle)*np.cos(spread_x)) tfq.convert_to_tensor(q_data), np.array(labels), bloch qubit = cirq.GridQubit( , )
theta_a = theta_b = num_samples = q_data, labels, bloch_p = generate_dataset(qubit, theta_a, theta_b, num_samples theta = sympy.Symbol( )
q_model = cirq.Circuit(cirq.ry(theta)(qubit))
q_data_input = tf.keras.Input(
    shape=(), dtype=tf.dtypes.string)
expectation = tfq.layers.PQC(q_model, cirq.Z(qubit))
expectation_output = expectation(q_data_input) classifier = tf.keras.layers.Dense( , activation=tf.keras.activations.softmax)
classifier_output = classifier(expectation_output)
model = tf.keras.Model(inputs=q_data_input, outputs=classifier_output) model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate= ),
              loss=tf.keras.losses.CategoricalCrossentropy())
tf.keras.utils.plot_model(model, show_shapes= , dpi= ) history = model.fit(x=q_data, y=labels, epochs= , verbose= )

test_data, _, _ = generate_dataset(qubit, theta_a, theta_b, )
p = model.predict(test_data)[ ]
print( ) #Importing dependencies 0.7 .0 2.1 .0 import import as import import import import as import as #Quantum Dataset : def generate_dataset (qubit, theta_a, theta_b, num_samples) """Generate a dataset of points on `qubit` near the two given angles; labels
  for the two clusters use a one-hot encoding.
  """ "a" "b" 5 for in if 0.5 1 0 "a" else 0 1 "b" 0 1 2 return #Genrate the dataset 0 0 1 4 200 #Model #We will use a parameterized rotation about the Y axis followed by a Z-axis measurement as the quantum portion of our model. For the classical portion, we will use a two-unit SoftMax which should learn to distinguish the measurement statistics of the two data sources. # Build the quantum model layer 'theta' # Attach the classical SoftMax classifier 2 # Standard compilation for classification 0.1 True 70 #Training 50 0 1 0 f"prob(a)= , prob(b)= " {p[ ]: f} 0 .4 {p[ ]: f} 1 .4 Conclusion So, we discovered about the Quantaum neural network in easy steps and even implemented it with TensorFlow Quantaum. Thanking and References Congratulations, Masoud Mohseni and the whole Tensorflow Quantum team for building such a wonderful system, it's a quantum leap in the history of machine learning. Please read the research paper to know more thoroughly. Thanks, Masoud Mohseni and whole Tensorflow Quantum team for creating such a great framework, It’s a quantum leap in the history of machine learning. please read the research paper to learn things deeply. Paper - TensorFlow Quantum: A Software Framework for Quantum Machine Learning . https://arxiv.org/abs/2003.02989 Thank you everyone!

Quantum Machine Learning Using TensorFlow Quantum

Too Long; Didn't Read

Company Mentioned

Neural Monk

About Author

TOPICS

THIS ARTICLE WAS FEATURED IN...