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-independent 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 abstractQuantumCircuitobject 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 Braket 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 Braket
backend.
from qadence import backend_factory
# Use only Braket in non-differentiable mode:
backend = backend_factory("braket")
# 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 = Circuit('instructions': [Instruction('operator': Rx('angle': 1d0ad34a-217d-43b7-98e8-6b8031d8847c, 'qubit_count': 1), 'target': QubitSet([Qubit(0)]), 'control': QubitSet([]), 'control_state': (), 'power': 1), Instruction('operator': Rz('angle': 2da0cc44-5bfe-4090-81d2-b5148aa54ec2, 'qubit_count': 1), 'target': QubitSet([Qubit(1)]), 'control': QubitSet([]), 'control_state': (), 'power': 1), Instruction('operator': CNot('qubit_count': 2), 'target': QubitSet([Qubit(0), Qubit(1)]), 'control': QubitSet([]), 'control_state': (), 'power': 1), Instruction('operator': Rx('angle': 655d4e3c-9a43-47bc-b801-7d3cc978a766, 'qubit_count': 1), 'target': QubitSet([Qubit(0)]), 'control': QubitSet([]), 'control_state': (), 'power': 1), Instruction('operator': Rx('angle': 97aa2e80-f0d5-42d3-b5ea-10844f7cc1ca, 'qubit_count': 1), 'target': QubitSet([Qubit(1)]), 'control': QubitSet([]), 'control_state': (), 'power': 1), Instruction('operator': Rx('angle': 03419f7a-4b68-4903-bfb0-1b284e8f456d, 'qubit_count': 1), 'target': QubitSet([Qubit(2)]), 'control': QubitSet([]), 'control_state': (), 'power': 1), Instruction('operator': Ry('angle': 79567766-ec5b-4f96-b094-a4ab490b662b, 'qubit_count': 1), 'target': QubitSet([Qubit(0)]), 'control': QubitSet([]), 'control_state': (), 'power': 1), Instruction('operator': Ry('angle': 06148643-0782-422e-98f2-22e952e1a2a7, 'qubit_count': 1), 'target': QubitSet([Qubit(1)]), 'control': QubitSet([]), 'control_state': (), 'power': 1), Instruction('operator': Ry('angle': 17458193-37e1-4625-9bc7-b443e0f779bc, 'qubit_count': 1), 'target': QubitSet([Qubit(2)]), 'control': QubitSet([]), 'control_state': (), 'power': 1), Instruction('operator': Rx('angle': b1d14ec2-291d-4545-8785-b6140e5596e4, 'qubit_count': 1), 'target': QubitSet([Qubit(0)]), 'control': QubitSet([]), 'control_state': (), 'power': 1), Instruction('operator': Rx('angle': daef356d-9e4a-4024-8917-07a4df0d2d3d, 'qubit_count': 1), 'target': QubitSet([Qubit(1)]), 'control': QubitSet([]), 'control_state': (), 'power': 1), Instruction('operator': Rx('angle': 0f40f320-bc01-407b-99a6-5fc7974251e8, 'qubit_count': 1), 'target': QubitSet([Qubit(2)]), 'control': QubitSet([]), 'control_state': (), 'power': 1), Instruction('operator': CNot('qubit_count': 2), 'target': QubitSet([Qubit(0), Qubit(1)]), 'control': QubitSet([]), 'control_state': (), 'power': 1), Instruction('operator': CNot('qubit_count': 2), 'target': QubitSet([Qubit(1), Qubit(2)]), 'control': QubitSet([]), 'control_state': (), 'power': 1)])
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_0: tensor([0.7131], requires_grad=True)
theta_7: tensor([0.5374], requires_grad=True)
theta_1: tensor([0.8713], requires_grad=True)
theta_4: tensor([0.8340], requires_grad=True)
theta_5: tensor([0.5387], requires_grad=True)
theta_3: tensor([0.6150], requires_grad=True)
theta_2: tensor([0.3381], requires_grad=True)
theta_6: tensor([0.7715], requires_grad=True)
theta_8: tensor([0.1420], requires_grad=True)
}
embedded = {
1d0ad34a-217d-43b7-98e8-6b8031d8847c: tensor([3., 3.], grad_fn=<ViewBackward0>)
2da0cc44-5bfe-4090-81d2-b5148aa54ec2: tensor([2., 2.])
655d4e3c-9a43-47bc-b801-7d3cc978a766: tensor([0.7131], grad_fn=<ViewBackward0>)
97aa2e80-f0d5-42d3-b5ea-10844f7cc1ca: tensor([0.8713], grad_fn=<ViewBackward0>)
03419f7a-4b68-4903-bfb0-1b284e8f456d: tensor([0.3381], grad_fn=<ViewBackward0>)
79567766-ec5b-4f96-b094-a4ab490b662b: tensor([0.6150], grad_fn=<ViewBackward0>)
06148643-0782-422e-98f2-22e952e1a2a7: tensor([0.8340], grad_fn=<ViewBackward0>)
17458193-37e1-4625-9bc7-b443e0f779bc: tensor([0.5387], grad_fn=<ViewBackward0>)
b1d14ec2-291d-4545-8785-b6140e5596e4: tensor([0.7715], grad_fn=<ViewBackward0>)
daef356d-9e4a-4024-8917-07a4df0d2d3d: tensor([0.5374], grad_fn=<ViewBackward0>)
0f40f320-bc01-407b-99a6-5fc7974251e8: tensor([0.1420], grad_fn=<ViewBackward0>)
}
Note that above the parameters keys have changed as they now address the keys on the Braket device. A more readable embedding is provided by the PyQTorch backend:
from qadence import BackendName, DiffMode
pyq_backend = backend_factory(backend=BackendName.PYQTORCH, diff_mode=DiffMode.AD)
# the `Converted` object
# (contains a `ConvertedCircuit` wiht the original and native representation)
pyq_conv = pyq_backend.convert(circuit)
embedded = pyq_conv.embedding_fn(pyq_conv.params, inputs)
embedded = {
theta_0: tensor([0.7131], grad_fn=<ViewBackward0>)
theta_7: tensor([0.5374], grad_fn=<ViewBackward0>)
theta_1: tensor([0.8713], grad_fn=<ViewBackward0>)
theta_4: tensor([0.8340], grad_fn=<ViewBackward0>)
theta_5: tensor([0.5387], grad_fn=<ViewBackward0>)
theta_3: tensor([0.6150], grad_fn=<ViewBackward0>)
theta_2: tensor([0.3381], grad_fn=<ViewBackward0>)
theta_6: tensor([0.7715], grad_fn=<ViewBackward0>)
y: tensor([2., 2.])
theta_8: tensor([0.1420], grad_fn=<ViewBackward0>)
3*x: tensor([3., 3.], grad_fn=<ViewBackward0>)
}
With the embedded parameters, QuantumModel methods are accessible:
embedded = conv.embedding_fn(conv.params, inputs)
samples = backend.run(conv.circuit, embedded)
print(f"{samples = }")
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, Braket noise features can be imported which are not exposed directly by Qadence.
from braket.circuits import Noise
# Get the native Braket circuit with the given parameters
inputs = {"x": torch.rand(1), "y":torch.rand(1)}
embedded = conv.embedding_fn(conv.params, inputs)
native = backend.assign_parameters(conv.circuit, embedded)
# Define a noise channel
noise = Noise.Depolarizing(probability=0.1)
# Add noise to every gate in the circuit
native.apply_gate_noise(noise)
In order to run this noisy circuit, the density matrix simulator is needed in Braket:
from braket.devices import LocalSimulator
device = LocalSimulator("braket_dm")
result = device.run(native, shots=1000).result().measurement_counts
print(result)
T : | 0 | 1 | 2 | 3 | 4 |5|6|
q0 : -Rx(1d0ad34a-217d-43b7-98e8-6b8031d8847c)-C----------------------------------------Rx(655d4e3c-9a43-47bc-b801-7d3cc978a766)-Ry(79567766-ec5b-4f96-b094-a4ab490b662b)-Rx(b1d14ec2-291d-4545-8785-b6140e5596e4)-C---
| |
q1 : -Rz(2da0cc44-5bfe-4090-81d2-b5148aa54ec2)-X----------------------------------------Rx(97aa2e80-f0d5-42d3-b5ea-10844f7cc1ca)-Ry(06148643-0782-422e-98f2-22e952e1a2a7)-Rx(daef356d-9e4a-4024-8917-07a4df0d2d3d)-X-C-
|
q2 : -Rx(03419f7a-4b68-4903-bfb0-1b284e8f456d)-Ry(17458193-37e1-4625-9bc7-b443e0f779bc)-Rx(0f40f320-bc01-407b-99a6-5fc7974251e8)-------------------------------------------------------------------------------------X-
T : | 0 | 1 | 2 | 3 | 4 |5|6|
Unassigned parameters: [03419f7a-4b68-4903-bfb0-1b284e8f456d, 06148643-0782-422e-98f2-22e952e1a2a7, 0f40f320-bc01-407b-99a6-5fc7974251e8, 17458193-37e1-4625-9bc7-b443e0f779bc, 1d0ad34a-217d-43b7-98e8-6b8031d8847c, 2da0cc44-5bfe-4090-81d2-b5148aa54ec2, 655d4e3c-9a43-47bc-b801-7d3cc978a766, 79567766-ec5b-4f96-b094-a4ab490b662b, 97aa2e80-f0d5-42d3-b5ea-10844f7cc1ca, b1d14ec2-291d-4545-8785-b6140e5596e4, daef356d-9e4a-4024-8917-07a4df0d2d3d].
T : | 0 | 1 | 2 | 3 | 4 | 5 | 6 |
q0 : -Rx(0.21)-DEPO(0.1)-C--------DEPO(0.1)-Rx(0.71)-DEPO(0.1)-Ry(0.61)-DEPO(0.1)-Rx(0.77)-DEPO(0.1)-C-DEPO(0.1)-------------
| |
q1 : -Rz(0.59)-DEPO(0.1)-X--------DEPO(0.1)-Rx(0.87)-DEPO(0.1)-Ry(0.83)-DEPO(0.1)-Rx(0.54)-DEPO(0.1)-X-DEPO(0.1)-C-DEPO(0.1)-
|
q2 : -Rx(0.34)-DEPO(0.1)-Ry(0.54)-DEPO(0.1)-Rx(0.14)-DEPO(0.1)---------------------------------------------------X-DEPO(0.1)-
T : | 0 | 1 | 2 | 3 | 4 | 5 | 6 |