quantum machine learning (qml) can be effectively implemented using the python programming language. the unique capabilities of python make it suitable for quantum machine learning. researchers can combine the quantum mechanics principles with flexibility of python libraries such as qiskit and cirq to develop and implement ml algorithms.

researchers can explore novel approaches to solve complex problems in fields like drug discovery, financial modeling, etc., where traditional ml may fall short.

what is quantum machine learning?

quantum machine learning is an interdisciplinary research area that combines fields such as quantum computing, machine learning, optimization, etc. to improve the performance of machine learning models.

it applies unique capabilities of quantum computers to enhance the performance of machine learning algorithms. qml is capable of performing computations beyond the capabilities of conventional computers.

why python for quantum machine learning?

there are many programming languages such as python, julia, c++, q#, etc., that are being used for quantum machine learning. but python is the most popular among these programming languages.

python is easy to learn and easy to implement machine learning algorithms for beginners as well as experienced.

python provides many popular libraries and frameworks for quantum machine learning. some popular ones include pennylane, qiskit, cirq, etc.

python also provides many scientific computing libraries such as scipy, pandas, scikit-learn, etc. python integrates these libraries with qml libraries.

python libraries/ frameworks for quantum machine learning

python offers many libraries and frameworks that are currently being used for quantum machine learning. the following are a few of important libraries -

pennylane − a popular and user-friendly library for building and training quantum machine learning models.
qiskit − it is a comprehensive quantum computing framework developed by ibm. it includes a dedicated module on qml. it provides various algorithms, simulators, etc., through the ibm cloud platform.
cirq − developed by google, it is another powerful quantum computing framework that supports quantum machine learning.
tensorflow quantum (tfq) minus; it is a quantum machine learning library for rapid prototyping of hybrid quantum-classical ml models.
squlearn − it is a user-friendly library that integrates quantum machine learning with classical machine learning libraries or tools such as scikit-learn.
pyquil − it is developed by rigetti computing. it is a python library for quantum programming and quantum machine learning. it provides tools for building and executing quantum circuits on rigetti's quantum processors.

quantum machine learning program with python

python is a very versatile programming language that provides many libraries for quantum machine learning. the main part of the qml is to design and execute quantum circuits.

with the help of python libraries, the designing and execution of quantum circuits are easy.

we need a specific quantum machine learning library to implement a qml program in python. in this section, we will use the pennylane python library for this purpose.

prerequisites

the following are the prerequisites for implementation of quantum machine learning in python -

programming language: python
qml library: pennylane
visualization library: matplotlib

get started with pennylane

we use the pennylane python library to implement the program below. it provides mechanisms to create and execute the quantum circuits. you can explore other python libraries as well.

before starting, you need to install the pennylane library.

pip install pennylane

steps

the following are the steps to perform a quantum machine learning program using python -

install and import required libraries
prepare training and test data
define a quantum device. specify the device type and the number of wires.
define the quantum circuit.
define pre-/post processing. here we define the loss function to find total loss.
define a cost function which takes in your quantum circuit and loss function.
perform optimization

choose an optimizer.
define the step size.
initialize the parameters (make an initial guess for the value of parameters).
iterate over a number of defined steps.

test and visualize the result.

program example

in the below example, we train a quantum circuit to model a sine function. we use the pennylane python library to define a quantum device and to create a quantum circuit. we use gradient descent optimizer as an optimization technique.

# program to train a quantum circuit to model a sine function
# step 1- import the necessary libraries
import pennylane as qml
from pennylane import numpy as np
import matplotlib.pyplot as plt

# step 2 - prepare the training data and test data
# training data preparation
x = np.linspace(0, 2*np.pi, 5) # 5 input datapoints from 0 to 2pi
x.requires_grad = false # prevent optimization of input data
y = np.sin(x) # corresponding outputs

# test data preparation
x_test = np.linspace(0.2, 2*np.pi+0.2, 5) # 5 test datapoints
y_test = np.sin(x_test) # corresponding outputs

# step 3 - quantum device setup
# using 'default.qubit' simulator with 1 qubit
dev = qml.device('default.qubit', wires=1)

# step 4 - create the quantum circuit
@qml.qnode(dev)
def quantum_circuit(input_data, params):
    """
    quantum circuit to model the sine function.

    args:
        input_data (float): input data point.
        params (array): parameters for the quantum gates.

    returns:
        float: expectation value of pauliz measurement.
    """
    # encode the input data as an rx rotation
    qml.rx(input_data, wires=0)
    # create a rotation based on the angles in "params"
    qml.rot(params[0], params[1], params[2], wires=0)
    # we return the expected value of a measurement along the z axis
    return qml.expval(qml.pauliz(wires=0))

# step 5 -loss function definition
def loss_func(predictions):
    total_losses = 0
    for i in range(len(y)):
        output = y[i]
        prediction = predictions[i]
        loss = (prediction - output)**2
        total_losses += loss
    return total_losses

# step 6 - cost function definition
def cost_fn(params):
    # cost function to be minimized during optimization.
    predictions = [quantum_circuit(x, params)  for x in x]
    cost = loss_func(predictions)
    return cost

# steps 7 - optimization step
# choose gradient descent optimizer and step size as 0.3
opt = qml.gradientdescentoptimizer(stepsize=0.3)

# initialize the parameters
params = np.array([0.1,0.1,0.1],requires_grad=true)

# iterate over a number of defined steps
for i in range (100):
    params, prev_cost = opt.step_and_cost(cost_fn,params)
    if i%10 == 0:
        # print the result after every 10 steps
        print(f'step {i} => cost = {cost_fn(params)}')

# step 8 - # testing and visualization
test_predictions = []
for x_test in x_test:
    prediction = quantum_circuit(x_test,params)
    test_predictions.append(prediction)

fig = plt.figure()
ax1 = fig.add_subplot(111)

ax1.scatter(x, y, s=30, c='b', marker="s", label='training data')
ax1.scatter(x_test,y_test, s=60, c='r', marker="o", label='test data')
ax1.scatter(x_test,test_predictions, s=30, c='k', marker="x", label='test predictions')
plt.xlabel("input")
plt.ylabel("output")
plt.title("quantum machine learning results")
plt.legend(loc='upper right');
plt.show()

output

step 0 => cost = 4.912499465469817
step 10 => cost = 0.01771261626471407
step 20 => cost = 0.0010549650559467845
step 30 => cost = 0.00033478390918249124
step 40 => cost = 0.00019081038150774426
step 50 => cost = 0.00012461609775915093
step 60 => cost = 8.781349557162982e-05
step 70 => cost = 6.52239822689053e-05
step 80 => cost = 5.0362401887345095e-05
step 90 => cost = 4.006386705383739e-05

implementing quantum machine learning with python

Save or share this article