Backends
Backends allow execution of Qadence abstract quantum circuits. They could be chosen from a variety of simulators, emulators and hardware
and can enable circuit differentiability. The primary way to interact and configure
a backend is via the high-level API QuantumModel
.
Not all backends are equivalent
Not all backends support the same set of operations, especially while executing analog blocks. Qadence will throw descriptive errors in such cases.
Execution backends
PyQTorch: An efficient, large-scale simulator designed for
quantum machine learning, seamlessly integrated with the popular PyTorch deep learning framework for automatic differentiability.
It also offers analog computing for time-(in)dependent pulses. See PyQTorchBackend
.
Pulser: A Python library for pulse-level/analog control of
neutral atom devices. Execution via QuTiP. See PulserBackend
.
More: Proprietary Qadence extensions provide more high-performance backends based on tensor networks or differentiation engines.
For more enquiries, please contact: info@pasqal.com
.
Differentiation backend
The DifferentiableBackend
class enables different differentiation modes
for the given backend. This can be chosen from two types:
- Automatic differentiation (AD): available for PyTorch based backends (PyQTorch).
- Parameter Shift Rules (PSR): available for all backends. See this section for more information on differentiability and PSR.
In practice, only a diff_mode
should be provided in the QuantumModel
. Please note that diff_mode
defaults to None
:
import sympy
import torch
from qadence import Parameter, RX, RZ, Z, CNOT, QuantumCircuit, QuantumModel, chain, BackendName, DiffMode
x = Parameter("x", trainable=False)
y = Parameter("y", trainable=False)
fm = chain(
RX(0, 3 * x),
RX(0, x),
RZ(1, sympy.exp(y)),
RX(0, 3.14),
RZ(1, "theta")
)
ansatz = CNOT(0, 1)
block = chain(fm, ansatz)
circuit = QuantumCircuit(2, block)
observable = Z(0)
# DiffMode.GPSR is available for any backend.
# DiffMode.AD is only available for natively differentiable backends.
model = QuantumModel(circuit, observable, backend=BackendName.PYQTORCH, diff_mode=DiffMode.GPSR)
# Get some values for the feature parameters.
values = {"x": (x := torch.tensor([0.5], requires_grad=True)), "y": torch.tensor([0.1])}
# Compute expectation.
exp = model.expectation(values)
# Differentiate the expectation wrt x.
dexp_dx = torch.autograd.grad(exp, x, torch.ones_like(exp))
Low-level backend_factory
interface
Every backend in Qadence inherits from the abstract Backend
class:
Backend
and implement the following methods:
run
: propagate the initial state according to the quantum circuit and return the final wavefunction object.sample
: sample from a circuit.expectation
: computes the expectation of a circuit given an observable.convert
: convert the abstractQuantumCircuit
object to its backend-native representation including a backend specific parameter embedding function.
Backends are purely functional objects which take as input the values for the circuit parameters and return the desired output from a call to a method. In order to use a backend directly, embedded parameters must be supplied as they are returned by the backend specific embedding function.
Here is a simple demonstration of the use of the PyQTorch backend to execute a circuit in non-differentiable mode:
from qadence import QuantumCircuit, FeatureParameter, RX, RZ, CNOT, hea, chain
# Construct a feature map.
x = FeatureParameter("x")
z = FeatureParameter("y")
fm = chain(RX(0, 3 * x), RZ(1, z), CNOT(0, 1))
# Construct a circuit with an hardware-efficient ansatz.
circuit = QuantumCircuit(3, fm, hea(3,1))
The abstract QuantumCircuit
can now be converted to its native representation via the PyQTorch
backend.
from qadence import backend_factory
# Use only PyQtorch in non-differentiable mode:
backend = backend_factory("pyqtorch")
# The `Converted` object
# (contains a `ConvertedCircuit` with the original and native representation)
conv = backend.convert(circuit)
conv.circuit.original = ChainBlock(0,1,2)
├── ChainBlock(0,1)
│ ├── RX(0) [params: ['3*x']]
│ ├── RZ(1) [params: ['y']]
│ └── CNOT(0, 1)
└── ChainBlock(0,1,2) [tag: HEA]
├── ChainBlock(0,1,2)
│ ├── KronBlock(0,1,2)
│ │ ├── RX(0) [params: ['theta_0']]
│ │ ├── RX(1) [params: ['theta_1']]
│ │ └── RX(2) [params: ['theta_2']]
│ ├── KronBlock(0,1,2)
│ │ ├── RY(0) [params: ['theta_3']]
│ │ ├── RY(1) [params: ['theta_4']]
│ │ └── RY(2) [params: ['theta_5']]
│ └── KronBlock(0,1,2)
│ ├── RX(0) [params: ['theta_6']]
│ ├── RX(1) [params: ['theta_7']]
│ └── RX(2) [params: ['theta_8']]
└── ChainBlock(0,1,2)
├── KronBlock(0,1)
│ └── CNOT(0, 1)
└── KronBlock(1,2)
└── CNOT(1, 2)
conv.circuit.native = QuantumCircuit(
(operations): ModuleList(
(0): Sequence(
(operations): ModuleList(
(0): Sequence(
(operations): ModuleList(
(0): RX(target: (0,), param: a25217fb-3556-49b8-a44d-c92752daa906)
(1): RZ(target: (1,), param: 19cc9211-cb2e-4de7-99d6-c31fd18ec2c9)
(2): CNOT(control: (0,), target: (1,))
)
)
(1): Sequence(
(operations): ModuleList(
(0): Sequence(
(operations): ModuleList(
(0): Merge(
(operations): ModuleList(
(0): RX(target: (0,), param: 2c782915-786b-4ebe-b9dd-c08fa2fa687e)
(1): RY(target: (0,), param: 548ef485-8c00-4858-bce2-78d6850fccce)
(2): RX(target: (0,), param: 944b50f0-3df6-4349-bf82-fe9aeb93a945)
)
)
(1): Merge(
(operations): ModuleList(
(0): RX(target: (1,), param: 44ccea8f-a203-4c28-8992-5837337e3e02)
(1): RY(target: (1,), param: 851fe64a-9b70-439b-9a66-de437d1b282c)
(2): RX(target: (1,), param: d98ad82c-cae3-43d7-8c19-077aa45e025f)
)
)
(2): Merge(
(operations): ModuleList(
(0): RX(target: (2,), param: 5c2c42fc-9064-4fb5-857b-3cbba3c12806)
(1): RY(target: (2,), param: 36d4c1a8-bec0-4b59-baeb-e18ac7d991b3)
(2): RX(target: (2,), param: 0d785898-5201-4213-a883-f25d587fcc8d)
)
)
)
)
(1): Sequence(
(operations): ModuleList(
(0): Sequence(
(operations): ModuleList(
(0): CNOT(control: (0,), target: (1,))
)
)
(1): Sequence(
(operations): ModuleList(
(0): CNOT(control: (1,), target: (2,))
)
)
)
)
)
)
)
)
)
)
Additionally, Converted
contains all fixed and variational parameters, as well as an embedding
function which accepts feature parameters to construct a dictionary of circuit native parameters.
These are needed as each backend uses a different representation of the circuit parameters:
import torch
# Contains fixed parameters and variational (from the HEA)
conv.params
inputs = {"x": torch.tensor([1., 1.]), "y":torch.tensor([2., 2.])}
# get all circuit parameters (including feature params)
embedded = conv.embedding_fn(conv.params, inputs)
conv.params = {
theta_6: tensor([0.1990], requires_grad=True)
theta_5: tensor([0.5638], requires_grad=True)
theta_0: tensor([0.3975], requires_grad=True)
theta_7: tensor([0.0192], requires_grad=True)
theta_2: tensor([0.0217], requires_grad=True)
theta_4: tensor([0.0650], requires_grad=True)
theta_8: tensor([0.2804], requires_grad=True)
theta_3: tensor([0.9994], requires_grad=True)
theta_1: tensor([0.4961], requires_grad=True)
}
embedded = {
a25217fb-3556-49b8-a44d-c92752daa906: tensor([3., 3.], grad_fn=<ViewBackward0>)
19cc9211-cb2e-4de7-99d6-c31fd18ec2c9: tensor([2., 2.])
2c782915-786b-4ebe-b9dd-c08fa2fa687e: tensor([0.3975], grad_fn=<ViewBackward0>)
548ef485-8c00-4858-bce2-78d6850fccce: tensor([0.9994], grad_fn=<ViewBackward0>)
944b50f0-3df6-4349-bf82-fe9aeb93a945: tensor([0.1990], grad_fn=<ViewBackward0>)
44ccea8f-a203-4c28-8992-5837337e3e02: tensor([0.4961], grad_fn=<ViewBackward0>)
851fe64a-9b70-439b-9a66-de437d1b282c: tensor([0.0650], grad_fn=<ViewBackward0>)
d98ad82c-cae3-43d7-8c19-077aa45e025f: tensor([0.0192], grad_fn=<ViewBackward0>)
5c2c42fc-9064-4fb5-857b-3cbba3c12806: tensor([0.0217], grad_fn=<ViewBackward0>)
36d4c1a8-bec0-4b59-baeb-e18ac7d991b3: tensor([0.5638], grad_fn=<ViewBackward0>)
0d785898-5201-4213-a883-f25d587fcc8d: tensor([0.2804], grad_fn=<ViewBackward0>)
}
With the embedded parameters, QuantumModel
methods are accessible:
output = tensor([[ 0.1345-0.1265j, 0.0219-0.0564j, 0.1319+0.0874j, 0.2485+0.4139j,
-0.6961-0.3491j, -0.2552-0.0051j, 0.0017+0.0561j, -0.0691+0.1566j],
[ 0.1345-0.1265j, 0.0219-0.0564j, 0.1319+0.0874j, 0.2485+0.4139j,
-0.6961-0.3491j, -0.2552-0.0051j, 0.0017+0.0561j, -0.0691+0.1566j]],
grad_fn=<TBackward0>)
Lower-level: the Backend
representation
If there is a requirement to work with a specific backend, it is possible to access directly the native circuit.
For example, should one wish to use PyQtorch noise features directly instead of using the NoiseHandler
interface from Qadence:
from pyqtorch.noise import Depolarizing
inputs = {"x": torch.rand(1), "y":torch.rand(1)}
embedded = conv.embedding_fn(conv.params, inputs)
# Define a noise channel on qubit 0
noise = Depolarizing(0, error_probability=0.1)
# Add noise to circuit
conv.circuit.native.operations.append(noise)
When running With noise, one can see that the output is a density matrix: