def test_returning_non_measurements(self):
"""Test that an exception is raised if a non-measurement
is returned from the QNode."""
dev = qml.device("default.qubit", wires=2)
def func(x, y):
qml.RX(x, wires=0)
qml.RY(y, wires=1)
qml.CNOT(wires=[0, 1])
return 5
qn = QNode(func, dev)
with pytest.raises(qml.QuantumFunctionError,
match="must return either a single measurement"):
qn(5, 1)
def func(x, y):
qml.RX(x, wires=0)
qml.RY(y, wires=1)
qml.CNOT(wires=[0, 1])
return qml.expval(qml.PauliZ(0)), 5
qn = QNode(func, dev)
with pytest.raises(qml.QuantumFunctionError,
match="must return either a single measurement"):
qn(5, 1)
def test_correct_number_of_executions_torch(self):
"""Test that number of executions are tracked in the torch interface."""
torch = pytest.importorskip("torch")
def func():
qml.Hadamard(wires=0)
qml.CNOT(wires=[0, 1])
return qml.expval(qml.PauliZ(0))
dev = qml.device("default.qubit", wires=2)
qn = QNode(func, dev, interface="torch")
for i in range(2):
qn()
assert dev.num_executions == 2
qn2 = QNode(func, dev, interface="torch")
for i in range(3):
qn2()
assert dev.num_executions == 5
# qubit of different interface
qn3 = QNode(func, dev, interface="autograd")
qn3()
assert dev.num_executions == 6
def test_basic_tape_construction(self, tol):
"""Test that a quantum tape is properly constructed"""
dev = qml.device("default.qubit", wires=2)
def func(x, y):
qml.RX(x, wires=0)
qml.RY(y, wires=1)
qml.CNOT(wires=[0, 1])
return qml.expval(qml.PauliZ(0))
qn = QNode(func, dev)
x = 0.12
y = 0.54
res = qn(x, y)
assert isinstance(qn.qtape, JacobianTape)
assert len(qn.qtape.operations) == 3
assert len(qn.qtape.observables) == 1
assert qn.qtape.num_params == 2
expected = qn.qtape.execute(dev)
assert np.allclose(res, expected, atol=tol, rtol=0)
# when called, a new quantum tape is constructed
old_tape = qn.qtape
res2 = qn(x, y)
assert np.allclose(res, res2, atol=tol, rtol=0)
assert qn.qtape is not old_tape
def test_unknown_diff_method_string(self):
"""Test that an exception is raised for an unknown differentiation method string"""
dev = qml.device("default.qubit", wires=1)
with pytest.raises(
qml.QuantumFunctionError,
match="Differentiation method hello not recognized"):
QNode(dummyfunc, dev, diff_method="hello")
def test_unknown_diff_method_type(self):
"""Test that an exception is raised for an unknown differentiation method type"""
dev = qml.device("default.qubit", wires=1)
with pytest.raises(
qml.QuantumFunctionError,
match=
"Differentiation method 5 must be a gradient transform or a string",
):
QNode(dummyfunc, dev, diff_method=5)
def test_operator_all_wires(self, monkeypatch, tol):
"""Test that an operator that must act on all wires
does, or raises an error."""
monkeypatch.setattr(qml.RX, "num_wires", qml.operation.AllWires)
def circuit(x):
qml.RX(x, wires=0)
return qml.expval(qml.PauliZ(0))
dev = qml.device("default.qubit", wires=2)
qnode = QNode(circuit, dev)
with pytest.raises(qml.QuantumFunctionError,
match="Operator RX must act on all wires"):
qnode(0.5)
dev = qml.device("default.qubit", wires=1)
qnode = QNode(circuit, dev)
assert np.allclose(qnode(0.5), np.cos(0.5), atol=tol, rtol=0)
def test_integration(self):
"""Test if the error of the mitigated result is less than the error of the unmitigated
result for a circuit with known expectation values"""
from mitiq.zne.scaling import fold_global
from mitiq.zne.inference import RichardsonFactory
noise_strength = 0.05
dev_noise_free = qml.device("default.mixed", wires=2)
dev = qml.transforms.insert(qml.AmplitudeDamping, noise_strength)(dev_noise_free)
n_wires = 2
n_layers = 2
shapes = qml.SimplifiedTwoDesign.shape(n_wires, n_layers)
np.random.seed(0)
w1, w2 = [np.random.random(s) for s in shapes]
def circuit(w1, w2):
qml.SimplifiedTwoDesign(w1, w2, wires=range(2))
qml.adjoint(qml.SimplifiedTwoDesign)(w1, w2, wires=range(2))
return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliZ(1))
exact_qnode = QNode(circuit, dev_noise_free)
noisy_qnode = QNode(circuit, dev)
@qml.transforms.mitigate_with_zne([1, 2, 3], fold_global, RichardsonFactory.extrapolate)
@qnode(dev)
def mitigated_qnode(w1, w2):
qml.SimplifiedTwoDesign(w1, w2, wires=range(2))
qml.adjoint(qml.SimplifiedTwoDesign)(w1, w2, wires=range(2))
return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliZ(1))
exact_val = exact_qnode(w1, w2)
noisy_val = noisy_qnode(w1, w2)
mitigated_val = mitigated_qnode(w1, w2)
mitigated_err = np.abs(exact_val - mitigated_val)
noisy_err = np.abs(exact_val - noisy_val)
assert np.allclose(exact_val, [1, 1])
assert all(mitigated_err < noisy_err)
def test_correct_number_of_executions_autograd(self):
"""Test that number of executions are tracked in the autograd interface."""
def func():
qml.Hadamard(wires=0)
qml.CNOT(wires=[0, 1])
return qml.expval(qml.PauliZ(0))
dev = qml.device("default.qubit", wires=2)
qn = QNode(func, dev, interface="autograd")
for i in range(2):
qn()
assert dev.num_executions == 2
qn2 = QNode(func, dev, interface="autograd")
for i in range(3):
qn2()
assert dev.num_executions == 5
def test_invalid_interface(self):
"""Test that an exception is raised for an invalid interface"""
dev = qml.device("default.qubit", wires=1)
test_interface = "something"
expected_error = (
fr"Unknown interface {test_interface}\. Interface must be "
r"one of \[None, 'autograd', 'numpy', 'jax', 'JAX', 'torch', 'pytorch', 'tf', 'tensorflow'\]\."
)
with pytest.raises(qml.QuantumFunctionError, match=expected_error):
QNode(dummyfunc, dev, interface="something")
def test_diff_method(self, mocker):
"""Test that a user-supplied diff method correctly returns the right
diff method."""
dev = qml.device("default.qubit", wires=1)
mock_best = mocker.patch("pennylane.beta.QNode.get_best_method")
mock_best.return_value = ("best", {}, dev)
mock_backprop = mocker.patch(
"pennylane.beta.QNode._validate_backprop_method")
mock_backprop.return_value = ("backprop", {}, dev)
mock_device = mocker.patch(
"pennylane.beta.QNode._validate_device_method")
mock_device.return_value = ("device", {}, dev)
qn = QNode(dummyfunc, dev, diff_method="best")
assert qn.diff_method == "best"
assert qn.gradient_fn == "best"
qn = QNode(dummyfunc, dev, diff_method="backprop")
assert qn.diff_method == "backprop"
assert qn.gradient_fn == "backprop"
mock_backprop.assert_called_once()
qn = QNode(dummyfunc, dev, diff_method="device")
assert qn.diff_method == "device"
assert qn.gradient_fn == "device"
mock_device.assert_called_once()
qn = QNode(dummyfunc, dev, diff_method="finite-diff")
assert qn.diff_method == "finite-diff"
assert qn.gradient_fn is qml.gradients.finite_diff
qn = QNode(dummyfunc, dev, diff_method="parameter-shift")
assert qn.diff_method == "parameter-shift"
assert qn.gradient_fn is qml.gradients.param_shift
# check that get_best_method was only ever called once
mock_best.assert_called_once()
def test_qnode_print(self):
"""Test that printing a QNode object yields the right information."""
dev = qml.device("default.qubit", wires=1)
def func(x):
qml.RX(x, wires=0)
return qml.expval(qml.PauliZ(0))
qn = QNode(func, dev)
assert (
qn.__repr__() ==
"<QNode: wires=1, device='default.qubit.autograd', interface='autograd', diff_method='best'>"
)
def test_consistent_measurement_order(self):
"""Test evaluation proceeds as expected if measurements are returned in the
same order to how they were queued on the tape"""
dev = qml.device("default.qubit", wires=2)
def func(x, y):
global op1, op2, op3, m1, m2
op1 = qml.RX(x, wires=0)
op2 = qml.RY(y, wires=1)
op3 = qml.CNOT(wires=[0, 1])
m1 = qml.expval(qml.PauliZ(0))
m2 = qml.expval(qml.PauliX(1))
return [m1, m2]
qn = QNode(func, dev)
qn(5, 1) # evaluate the QNode
assert qn.qtape.operations == [op1, op2, op3]
assert qn.qtape.measurements == [m1, m2]
def test_inconsistent_measurement_order(self):
"""Test that an exception is raised if measurements are returned in an
order different to how they were queued on the tape"""
dev = qml.device("default.qubit", wires=2)
def func(x, y):
qml.RX(x, wires=0)
qml.RY(y, wires=1)
qml.CNOT(wires=[0, 1])
m = qml.expval(qml.PauliZ(0))
return qml.expval(qml.PauliX(1)), m
qn = QNode(func, dev)
with pytest.raises(
qml.QuantumFunctionError,
match=
"measurements must be returned in the order they are measured",
):
qn(5, 1)
def test_jacobian(self, tol):
"""Test the jacobian computation"""
dev = qml.device("default.qubit", wires=2)
def func(x, y):
qml.RX(x, wires=0)
qml.RY(y, wires=1)
qml.CNOT(wires=[0, 1])
return qml.probs(wires=0), qml.probs(wires=1)
qn = QNode(func,
dev,
diff_method="finite-diff",
h=1e-8,
approx_order=2)
assert qn.gradient_kwargs["h"] == 1e-8
assert qn.gradient_kwargs["approx_order"] == 2
jac = qn.gradient_fn(qn)(0.45, 0.1)
assert jac.shape == (2, 2, 2)
def test_no_shots_per_call_if_user_has_shots_qfunc_kwarg(self):
"""Tests that the per-call shots overwriting is suspended if user
has a shots keyword argument, but a warning is raised."""
dev = qml.device("default.qubit", wires=2, shots=10)
def circuit(a, shots=0):
qml.RX(a, wires=shots)
return qml.sample(qml.PauliZ(wires=0))
with pytest.warns(
UserWarning,
match="The 'shots' argument name is reserved for overriding"):
circuit = QNode(circuit, dev)
assert len(circuit(0.8)) == 10
assert circuit.qtape.operations[0].wires.labels == (0, )
assert len(circuit(0.8, shots=1)) == 10
assert circuit.qtape.operations[0].wires.labels == (1, )
assert len(circuit(0.8, shots=0)) == 10
assert circuit.qtape.operations[0].wires.labels == (0, )
def test_no_shots_per_call_if_user_has_shots_qfunc_arg(self):
"""Tests that the per-call shots overwriting is suspended
if user has a shots argument, but a warning is raised."""
# Todo: use standard creation of qnode below for both asserts once we do not parse args to tensors any more
dev = qml.device("default.qubit",
wires=[qml.numpy.array(0),
qml.numpy.array(1)],
shots=10)
def circuit(a, shots):
qml.RX(a, wires=shots)
return qml.sample(qml.PauliZ(wires=qml.numpy.array(0)))
# assert that warning is still raised
with pytest.warns(
UserWarning,
match="The 'shots' argument name is reserved for overriding"):
circuit = QNode(circuit, dev)
assert len(circuit(0.8, 1)) == 10
assert circuit.qtape.operations[0].wires.labels == (1, )
dev = qml.device("default.qubit", wires=2, shots=10)
with pytest.warns(
UserWarning,
match="The 'shots' argument name is reserved for overriding"):
@qnode(dev)
def circuit(a, shots):
qml.RX(a, wires=shots)
return qml.sample(qml.PauliZ(wires=0))
assert len(circuit(0.8, shots=0)) == 10
assert circuit.qtape.operations[0].wires.labels == (0, )
def test_invalid_device(self):
"""Test that an exception is raised for an invalid device"""
with pytest.raises(qml.QuantumFunctionError, match="Invalid device"):
QNode(dummyfunc, None)
