def test_expand_no_observable(self):
"""Check that an exception is raised if the measurement to
be expanded has no observable"""
m = MeasurementProcess(Probability, wires=qml.wires.Wires([0, 1]))
with pytest.raises(NotImplementedError, match="Cannot expand"):
m.expand()
def test_repr(self):
"""Test the string representation of a MeasurementProcess."""
m = MeasurementProcess(Expectation, obs=qml.PauliZ(wires="a") @ qml.PauliZ(wires="b"))
expected = "expval(PauliZ(wires=['a']) @ PauliZ(wires=['b']))"
assert str(m) == expected
m = MeasurementProcess(Probability, obs=qml.PauliZ(wires="a"))
expected = "probs(PauliZ(wires=['a']))"
assert str(m) == expected
def test_observable_with_no_eigvals(self):
"""An observable with no eigenvalues defined should cause
the eigvals property on the associated measurement process
to be None"""
obs = qml.NumberOperator(wires=0)
m = MeasurementProcess(Expectation, obs=obs)
assert m.eigvals is None
def test_error_obs_and_wires(self):
"""Test that providing both wires and an observable
results in an error"""
obs = qml.Hermitian(np.diag([1, 2, 3]), wires=[0, 1, 2])
with pytest.raises(ValueError, match="Cannot set the wires"):
MeasurementProcess(Expectation, obs=obs, wires=qml.wires.Wires([0, 1]))
def test_wires_match_observable(self):
"""Test that the wires of the measurement process
match an internal observable"""
obs = qml.Hermitian(np.diag([1, 2, 3]), wires=["a", "b", "c"])
m = MeasurementProcess(Expectation, obs=obs)
assert np.all(m.wires == obs.wires)
def test_eigvals_match_observable(self):
"""Test that the eigenvalues of the measurement process
match an internal observable"""
obs = qml.Hermitian(np.diag([1, 2, 3]), wires=[0, 1, 2])
m = MeasurementProcess(Expectation, obs=obs)
assert np.all(m.eigvals == np.array([1, 2, 3]))
# changing the observable data should be reflected
obs.data = [np.diag([5, 6, 7])]
assert np.all(m.eigvals == np.array([5, 6, 7]))
def test_expand_pauli(self):
"""Test the expansion of a Pauli observable"""
obs = qml.PauliX(0) @ qml.PauliY(1)
m = MeasurementProcess(Expectation, obs=obs)
tape = m.expand()
assert len(tape.operations) == 4
assert tape.operations[0].name == "Hadamard"
assert tape.operations[0].wires.tolist() == [0]
assert tape.operations[1].name == "PauliZ"
assert tape.operations[1].wires.tolist() == [1]
assert tape.operations[2].name == "S"
assert tape.operations[2].wires.tolist() == [1]
assert tape.operations[3].name == "Hadamard"
assert tape.operations[3].wires.tolist() == [1]
assert len(tape.measurements) == 1
assert tape.measurements[0].return_type is Expectation
assert tape.measurements[0].wires.tolist() == [0, 1]
assert np.all(tape.measurements[0].eigvals == np.array([1, -1, -1, 1]))
def test_expand_hermitian(self, tol):
"""Test the expansion of an hermitian observable"""
H = np.array([[1, 2], [2, 4]])
obs = qml.Hermitian(H, wires=["a"])
m = MeasurementProcess(Expectation, obs=obs)
tape = m.expand()
assert len(tape.operations) == 1
assert tape.operations[0].name == "QubitUnitary"
assert tape.operations[0].wires.tolist() == ["a"]
assert np.allclose(
tape.operations[0].parameters[0],
np.array([[-2, 1], [1, 2]]) / np.sqrt(5),
atol=tol,
rtol=0,
)
assert len(tape.measurements) == 1
assert tape.measurements[0].return_type is Expectation
assert tape.measurements[0].wires.tolist() == ["a"]
assert np.all(tape.measurements[0].eigvals == np.array([0, 5]))
def parameter_shift_var(self, idx, params, **options):
"""Generate the tapes and postprocessing methods required to compute the gradient of a
parameter and its variance using the parameter-shift method.
Args:
idx (int): trainable parameter index to differentiate with respect to
params (list[Any]): the quantum tape operation parameters
Keyword Args:
shift=pi/2 (float): the size of the shift for two-term parameter-shift gradient computations
Returns:
tuple[list[QuantumTape], function]: A tuple containing the list of generated tapes,
in addition to a post-processing function to be applied to the evaluated
tapes.
"""
tapes = []
# Get <A>, the expectation value of the tape with unshifted parameters.
evA_tape = self.copy()
evA_tape.set_parameters(params)
# Convert all variance measurements on the tape into expectation values
for i in self.var_idx:
obs = evA_tape._measurements[i].obs
evA_tape._measurements[i] = MeasurementProcess(
qml.operation.Expectation, obs=obs)
# evaluate the analytic derivative of <A>
pdA_tapes, pdA_fn = evA_tape.parameter_shift(idx, params, **options)
tapes.extend(pdA_tapes)
# For involutory observables (A^2 = I) we have d<A^2>/dp = 0.
# Currently, the only observable we have in PL that may be non-involutory is qml.Hermitian
involutory = [
i for i in self.var_idx if self.observables[i].name != "Hermitian"
]
# If there are non-involutory observables A present, we must compute d<A^2>/dp.
non_involutory = set(self.var_idx) - set(involutory)
if non_involutory:
pdA2_tape = self.copy()
for i in non_involutory:
# We need to calculate d<A^2>/dp; to do so, we replace the
# involutory observables A in the queue with A^2.
obs = pdA2_tape._measurements[i].obs
A = obs.matrix
obs = qml.Hermitian(A @ A, wires=obs.wires, do_queue=False)
pdA2_tape._measurements[i] = MeasurementProcess(
qml.operation.Expectation, obs=obs)
# Non-involutory observables are present; the partial derivative of <A^2>
# may be non-zero. Here, we calculate the analytic derivatives of the <A^2>
# observables.
pdA2_tapes, pdA2_fn = pdA2_tape.parameter_shift(
idx, params, **options)
tapes.extend(pdA2_tapes)
# Make sure that the expectation value of the tape with unshifted parameters
# is only calculated once, if `self._append_evA_tape` is True.
if self._append_evA_tape:
tapes.append(evA_tape)
# Now that the <A> tape has been appended, we want to avoid
# appending it for subsequent parameters, as the result can simply
# be re-used.
self._append_evA_tape = False
def processing_fn(results):
"""Computes the gradient of the parameter at index ``idx`` via the
parameter-shift method for a circuit containing a mixture
of expectation values and variances.
Args:
results (list[real]): evaluated quantum tapes
Returns:
array[float]: 1-dimensional array of length determined by the tape output
measurement statistics
"""
pdA = pdA_fn(results[0:2])
pdA2 = 0
if non_involutory:
pdA2 = pdA2_fn(results[2:4])
if involutory:
pdA2[np.array(involutory)] = 0
# Check if the expectation value of the tape with unshifted parameters
# has already been calculated.
if self._evA_result is None:
# The expectation value hasn't been previously calculated;
# it will be the last element of the `results` argument.
self._evA_result = np.array(results[-1])
# return d(var(A))/dp = d<A^2>/dp -2 * <A> * d<A>/dp for the variances,
# d<A>/dp for plain expectations
return np.where(self.var_mask, pdA2 - 2 * self._evA_result * pdA,
pdA)
return tapes, processing_fn
def parameter_shift_var(self, idx, params, **options):
r"""Partial derivative using the first-order or second-order parameter-shift rule of a tape
consisting of a mixture of expectation values and variances of observables.
Expectation values may be of first- or second-order observables,
but variances can only be taken of first-order variables.
.. warning::
This method can only be executed on devices that support the
:class:`~.PolyXP` observable.
Args:
idx (int): trainable parameter index to differentiate with respect to
params (list[Any]): the quantum tape operation parameters
Keyword Args:
force_order2 (bool): iff True, use the order-2 method even if not necessary
device (.Device): A PennyLane device that can execute quantum operations and return
measurement statistics. This keyword argument is required, as the device labels
may be needed to generate the quantum tapes for computing the gradient.
Returns:
array[float]: 1-dimensional array of length determined by the tape output
measurement statistics
"""
# pylint: disable=protected-access
device = options["device"]
if "PolyXP" not in device.observables:
# If the device does not support PolyXP, must fallback
# to numeric differentiation.
warnings.warn(
f"The device {device.short_name} does not support "
"the PolyXP observable. The analytic parameter-shift cannot be used for "
"second-order observables; falling back to finite-differences.",
UserWarning,
)
return self.numeric_pd(idx, params, **options)
tapes = []
# Get <A>, the expectation value of the tape with unshifted parameters.
evA_tape = self.copy()
evA_tape.set_parameters(params)
# Temporarily convert all variance measurements on the tape into expectation values
for i in self.var_idx:
obs = evA_tape._measurements[i].obs
evA_tape._measurements[i] = MeasurementProcess(
qml.operation.Expectation, obs=obs)
# evaluate the analytic derivative of <A>
pdA_tapes, pdA_fn = evA_tape.parameter_shift_first_order(
idx, params, **options)
tapes.extend(pdA_tapes)
pdA2_tape = self.copy()
for i in self.var_idx:
# We need to calculate d<A^2>/dp; to do so, we replace the
# observables A in the queue with A^2.
obs = pdA2_tape._measurements[i].obs
# CV first order observable
# get the heisenberg representation
# This will be a real 1D vector representing the
# first order observable in the basis [I, x, p]
A = obs._heisenberg_rep(obs.parameters) # pylint: disable=protected-access
# take the outer product of the heisenberg representation
# with itself, to get a square symmetric matrix representing
# the square of the observable
obs = qml.PolyXP(np.outer(A, A), wires=obs.wires, do_queue=False)
pdA2_tape._measurements[i] = MeasurementProcess(
qml.operation.Expectation, obs=obs)
# Here, we calculate the analytic derivatives of the <A^2> observables.
pdA2_tapes, pdA2_fn = pdA2_tape.parameter_shift_second_order(
idx, params, **options)
tapes.extend(pdA2_tapes)
# Make sure that the expectation value of the tape with unshifted parameters
# is only calculated once, if `self._append_evA_tape` is True.
if self._append_evA_tape:
tapes.append(evA_tape)
# Now that the <A> tape has been appended, we want to avoid
# appending it for subsequent parameters, as the result can simply
# be re-used.
self._append_evA_tape = False
def processing_fn(results):
"""Computes the gradient of the parameter at index ``idx`` via the
second order CV parameter-shift method for a circuit containing a mixture
of expectation values and variances.
Args:
results (list[real]): evaluated quantum tapes
Returns:
array[float]: 1-dimensional array of length determined by the tape output
measurement statistics
"""
pdA = pdA_fn(results[0:2])
pdA2 = pdA2_fn(results[2:4])
# Check if the expectation value of the tape with unshifted parameters
# has already been calculated.
if self._evA_result is None:
# The expectation value hasn't been previously calculated;
# it will be the last element of the `results` argument.
self._evA_result = np.array(results[-1])
# return d(var(A))/dp = d<A^2>/dp -2 * <A> * d<A>/dp for the variances,
# d<A>/dp for plain expectations
return np.where(self.var_mask, pdA2 - 2 * self._evA_result * pdA,
pdA)
return tapes, processing_fn
def parameter_shift_second_order(self, idx, params, **options):
"""Generate the tapes and postprocessing methods required to compute the gradient of a
parameter using the second order CV parameter-shift method.
Args:
idx (int): trainable parameter index to differentiate with respect to
params (list[Any]): the quantum tape operation parameters
Keyword Args:
dev_wires (.Wires): wires on the device the parameter-shift method is computed on
Returns:
tuple[list[QuantumTape], function]: A tuple containing the list of generated tapes,
in addition to a post-processing function to be applied to the evaluated
tapes.
"""
t_idx = list(self.trainable_params)[idx]
op = self._par_info[t_idx]["op"]
p_idx = self._par_info[t_idx]["p_idx"]
dev_wires = options["dev_wires"]
param_shift = op.get_parameter_shift(p_idx)
if len(param_shift) != 2:
# The 2nd order CV parameter-shift rule only accepts two-term shifts
raise NotImplementedError(
"Taking the analytic gradient for order-2 operators is "
"unsupported for {op} which contains a parameter with a "
"gradient recipe of more than two terms.")
c1, a1, s1 = param_shift[0]
c2, a2, s2 = param_shift[1]
shift = np.zeros_like(params)
shift[idx] = s1
# evaluate transformed observables at the original parameter point
# first build the Heisenberg picture transformation matrix Z
self.set_parameters(a1 * params + shift)
Z2 = op.heisenberg_tr(dev_wires)
shift[idx] = s2
self.set_parameters(a2 * params + shift)
Z1 = op.heisenberg_tr(dev_wires)
# derivative of the operation
Z = Z2 * c1 + Z1 * c2
self.set_parameters(params)
Z0 = op.heisenberg_tr(dev_wires, inverse=True)
Z = Z @ Z0
# conjugate Z with all the descendant operations
B = np.eye(1 + 2 * len(dev_wires))
B_inv = B.copy()
succ = self.graph.descendants_in_order((op, ))
operation_descendents = itertools.filterfalse(
qml.circuit_graph._is_observable, succ)
observable_descendents = filter(qml.circuit_graph._is_observable, succ)
for BB in operation_descendents:
if not BB.supports_heisenberg:
# if the descendant gate is non-Gaussian in parameter-shift differentiation
# mode, then there must be no observable following it.
continue
B = BB.heisenberg_tr(dev_wires) @ B
B_inv = B_inv @ BB.heisenberg_tr(dev_wires, inverse=True)
Z = B @ Z @ B_inv # conjugation
tape = self.copy(copy_operations=True, tape_cls=QuantumTape)
# change the observable
# TODO: if the transformation produces only a constant term,
# `_transform_observable` has only a single non-zero element in the
# 0th position, then there is no need to execute the device---the constant term
# represents the gradient.
# transform the descendant observables into their derivatives using Z
transformed_obs_idx = []
for obs in observable_descendents:
# get the index of the descendent observable
idx = self.observables.index(obs)
transformed_obs_idx.append(idx)
tape._measurements[idx] = MeasurementProcess(
qml.operation.Expectation,
self._transform_observable(obs, Z, dev_wires))
tapes = [tape]
def processing_fn(results):
"""Computes the gradient of the parameter at index idx via the
second order CV parameter-shift method.
Args:
results (list[real]): evaluated quantum tapes
Returns:
array[float]: 1-dimensional array of length determined by the tape output
measurement statistics
"""
res = results[0]
grad = np.zeros_like(res)
grad[transformed_obs_idx] = res
return grad
return tapes, processing_fn