Source code for pennylane.transforms.mitigate

# Copyright 2021 Xanadu Quantum Technologies Inc.

# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at


# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# See the License for the specific language governing permissions and
# limitations under the License.
"""Provides transforms for mitigating quantum circuits."""
from copy import copy

from typing import Any, Dict, Optional, Sequence, Callable

from pennylane import apply, adjoint
from pennylane.math import mean, shape, round
from pennylane.queuing import AnnotatedQueue
from pennylane.tape import QuantumTape, QuantumScript
from pennylane.transforms import transform

import pennylane as qml

[docs]@transform def fold_global(tape: QuantumTape, scale_factor) -> (Sequence[QuantumTape], Callable): r"""Differentiable circuit folding of the global unitary ``circuit``. For a unitary circuit :math:`U = L_d .. L_1`, where :math:`L_i` can be either a gate or layer, ``fold_global`` constructs .. math:: \text{fold_global}(U) = U (U^\dagger U)^n (L^\dagger_d L^\dagger_{d-1} .. L^\dagger_s) (L_s .. L_d) where :math:`n = \lfloor (\lambda - 1)/2 \rfloor` and :math:`s = \lfloor \left(\lambda - 1 \right) (d/2) \rfloor` are determined via the ``scale_factor`` :math:`=\lambda`. The purpose of folding is to artificially increase the noise for zero noise extrapolation, see :func:`~.pennylane.transforms.mitigate_with_zne`. Args: tape (QNode or QuantumTape): the quantum circuit to be folded scale_factor (float): Scale factor :math:`\lambda` determining :math:`n` and :math:`s` Returns: qnode (QNode) or tuple[List[QuantumTape], function]: The folded circuit as described in :func:`qml.transform <pennylane.transform>`. .. seealso:: :func:`~.pennylane.transforms.mitigate_with_zne`; This function is analogous to the implementation in ``mitiq`` `mitiq.zne.scaling.fold_global <>`_. **Example** Let us look at the following circuit. .. code-block:: python x = np.arange(6) @qml.qnode(dev) def circuit(x): qml.RX(x[0], wires=0) qml.RY(x[1], wires=1) qml.RZ(x[2], wires=2) qml.CNOT(wires=(0,1)) qml.CNOT(wires=(1,2)) qml.RX(x[3], wires=0) qml.RY(x[4], wires=1) qml.RZ(x[5], wires=2) return qml.expval(qml.Z(0) @ qml.Z(1) @ qml.Z(2)) Setting ``scale_factor=1`` does not affect the circuit: >>> folded = qml.transforms.fold_global(circuit, 1) >>> print(qml.draw(folded)(x)) 0: ──RX(0.0)─╭●──RX(3.0)──────────┤ ╭<Z@Z@Z> 1: ──RY(1.0)─╰X─╭●────────RY(4.0)─┤ ├<Z@Z@Z> 2: ──RZ(2.0)────╰X────────RZ(5.0)─┤ ╰<Z@Z@Z> Setting ``scale_factor=2`` results in the partially folded circuit :math:`U (L^\dagger_d L^\dagger_{d-1} .. L^\dagger_s) (L_s .. L_d)` with :math:`s = \lfloor \left(1 \mod 2 \right) d/2 \rfloor = 4` since the circuit is composed of :math:`d=8` gates. >>> folded = qml.transforms.fold_global(circuit, 2) >>> print(qml.draw(folded)(x)) 0: ──RX(0.0)─╭●──RX(3.0)──RX(3.0)†──RX(3.0)──────────────────┤ ╭<Z@Z@Z> 1: ──RY(1.0)─╰X─╭●────────RY(4.0)───RY(4.0)†─╭●──╭●──RY(4.0)─┤ ├<Z@Z@Z> 2: ──RZ(2.0)────╰X────────RZ(5.0)───RZ(5.0)†─╰X†─╰X──RZ(5.0)─┤ ╰<Z@Z@Z> Setting ``scale_factor=3`` results in the folded circuit :math:`U (U^\dagger U)`. >>> folded = qml.transforms.fold_global(circuit, 3) >>> print(qml.draw(folded)(x)) 0: ──RX(0.0)─╭●──RX(3.0)──RX(3.0)†───────────────╭●─────────RX(0.0)†──RX(0.0)─╭●──RX(3.0)──────────┤╭<Z@Z@Z> 1: ──RY(1.0)─╰X─╭●────────RY(4.0)───RY(4.0)†─╭●──╰X†────────RY(1.0)†──RY(1.0)─╰X─╭●────────RY(4.0)─┤├<Z@Z@Z> 2: ──RZ(2.0)────╰X────────RZ(5.0)───RZ(5.0)†─╰X†──RZ(2.0)†──RZ(2.0)──────────────╰X────────RZ(5.0)─┤╰<Z@Z@Z> .. note:: Circuits are treated as lists of operations. Since the ordering of that list is ambiguous, so is its folding. This can be seen exemplarily for two equivalent unitaries :math:`U1 = X(0) Y(0) X(1) Y(1)` and :math:`U2 = X(0) X(1) Y(0) Y(1)`. The folded circuits according to ``scale_factor=2`` would be :math:`U1 (X(0) Y(0) Y(0) X(0))` and :math:`U2 (X(0) X(1) X(1) X(0))`, respectively. So even though :math:`U1` and :math:`U2` are describing the same quantum circuit, the ambiguity in their ordering as a list yields two differently folded circuits. .. details:: The main purpose of folding is for zero noise extrapolation (ZNE). PennyLane provides a differentiable transform :func:`~.pennylane.transforms.mitigate_with_zne` that allows you to perform ZNE as a black box. If you want more control and `see` the extrapolation, you can follow the logic of the following example. We start by setting up a noisy device using the mixed state simulator and a noise channel. .. code-block:: python n_wires = 4 # Describe noise noise_gate = qml.DepolarizingChannel noise_strength = 0.05 # Load devices dev_ideal = qml.device("default.mixed", wires=n_wires) dev_noisy = qml.transforms.insert(noise_gate, noise_strength)(dev_ideal) x = np.arange(6) H = 1.*qml.X(0) @ qml.X(1) + 1.*qml.X(1) @ qml.X(2) def circuit(x): qml.RY(x[0], wires=0) qml.RY(x[1], wires=1) qml.RY(x[2], wires=2) qml.CNOT(wires=(0,1)) qml.CNOT(wires=(1,2)) qml.RY(x[3], wires=0) qml.RY(x[4], wires=1) qml.RY(x[5], wires=2) return qml.expval(H) qnode_ideal = qml.QNode(circuit, dev_ideal) qnode_noisy = qml.QNode(circuit, dev_noisy) We can then create folded versions of the noisy qnode and execute them for different scaling factors. >>> scale_factors = [1., 2., 3.] >>> folded_res = [qml.transforms.fold_global(qnode_noisy, lambda_)(x) for lambda_ in scale_factors] We want to later compare the ZNE with the ideal result. >>> ideal_res = qnode_ideal(x) ZNE is, as the name suggests, an extrapolation in the noise to zero. The underlyding assumption is that the level of noise is proportional to the scaling factor by artificially increasing the circuit depth. We can perform a polynomial fit using ``numpy`` functions. Note that internally in :func:`~.pennylane.transforms.mitigate_with_zne` a differentiable polynomial fit function :func:`~.pennylane.transforms.poly_extrapolate` is used. >>> # coefficients are ordered like coeffs[0] * x**2 + coeffs[1] * x + coeffs[0] >>> coeffs = np.polyfit(scale_factors, folded_res, 2) >>> zne_res = coeffs[-1] We used a polynomial fit of ``order=2``. Using ``order=len(scale_factors) -1`` is also referred to as Richardson extrapolation and implemented in :func:`~.pennylane.transforms.richardson_extrapolate`. We can now visualize our fit to see how close we get to the ideal result with this mitigation technique. .. code-block:: python x_fit = np.linspace(0, 3, 20) y_fit = np.poly1d(coeffs)(x_fit) plt.plot(scale_factors, folded_res, "x--", label="folded") plt.plot(0, ideal_res, "X", label="ideal res") plt.plot(0, zne_res, "X", label="ZNE res", color="tab:red") plt.plot(x_fit, y_fit, label="fit", color="tab:red", alpha=0.5) plt.legend() .. figure:: ../../_static/fold_global_zne_by-hand.png :align: center :width: 60% :target: javascript:void(0); """ # The main intention for providing ``fold_global`` was for it to be used in combination with ``mitigate_with_zne``, which also works with mitiq functions. # To preserve the mitiq functionality, ``mitigate_with_zne`` should get a tape transform. # To make ``fold_global`` also user-facing and work with qnodes, this function is batch_transformed instead, and therefore applicable on qnodes. return [fold_global_tape(tape, scale_factor)], lambda x: x[0]
def _divmod(a, b): """Performs divmod but in an all-interface compatible manner""" out1 = qml.math.floor(a / b) out2 = a - out1 * b return int(out1), out2 def fold_global_tape(circuit, scale_factor): r""" This is the internal tape transform to be used with :func:`~.pennylane.transforms.mitigate_with_zne`. For the user-facing function see :func:`~.pennylane.transforms.fold_global`. Args: circuit (QuantumTape): the circuit to be folded scale_factor (float): Scale factor :math:`\lambda` determining :math:`n` and :math:`s` Returns: QuantumTape: Folded circuit """ # TODO: simplify queing via qfunc(op) - currently just a workaround, to solve the problem of ownership when tape contains adjoint(op) # already touched on the issue, future work # in Q3 2022 should make it possible to substantially simplify this. def qfunc(op): copy(op).queue() # Generate base_circuit without measurements # Treat all circuits as lists of operations, build new tape in the end base_ops = circuit.expand().copy(copy_operations=True).operations num_global_folds, fraction_scale = _divmod(scale_factor - 1, 2) n_ops = len(base_ops) num_to_fold = int(round(fraction_scale * n_ops / 2)) # Create new_circuit from folded list with AnnotatedQueue() as new_circuit_q: # Original U for op in base_ops: qfunc(op) # Folding U => U (U^H U)**n. for _ in range(int(num_global_folds)): for op in base_ops[::-1]: adjoint(qfunc)(op) for op in base_ops: qfunc(op) # Remainder folding U => U (U^H U)**n (L_d^H .. L_s^H) (L_s .. L_d) for i in range(n_ops - 1, n_ops - num_to_fold - 1, -1): adjoint(qfunc)(base_ops[i]) for i in range(n_ops - num_to_fold, n_ops): qfunc(base_ops[i]) # Append measurements for meas in circuit.measurements: apply(meas) return QuantumScript.from_queue(new_circuit_q) # TODO: make this a pennylane.math function def _polyfit(x, y, order): """Brute force implementation of polynomial fit""" x = qml.math.convert_like(x, y[0]) x = qml.math.cast_like(x, y[0]) X = qml.math.vander(x, order + 1) y = qml.math.stack(y) # scale X to improve condition number and solve scale = qml.math.sum(qml.math.sqrt((X * X)), axis=0) X = X / scale # Compute coeffs: # This part is typically done using a lstq solver, do it with the penrose inverse by hand: # i.e. coeffs = (X.T @ X)**-1 X.T @ y see c = qml.math.linalg.pinv(qml.math.transpose(X) @ X) c = c @ qml.math.transpose(X) c = qml.math.tensordot(c, y, axes=1) c = qml.math.transpose(qml.math.transpose(c) / scale) return c
[docs]def poly_extrapolate(x, y, order): r"""Extrapolator to :math:`f(0)` for polynomial fit. The polynomial is defined as ``f(x) = p[0] * x**deg + p[1] * x**(deg-1) + ... + p[deg]`` such that ``deg = order + 1``. This function is compatible with all interfaces supported by pennylane. Args: x (Array): Data in x y (Array): Data in y = f(x) order (int): Order of the polynomial fit Returns: float: Extrapolated value at f(0). .. seealso:: :func:`~.pennylane.transforms.richardson_extrapolate`, :func:`~.pennylane.transforms.mitigate_with_zne` **Example:** >>> x = np.linspace(1, 10, 5) >>> y = x**2 + x + 1 + 0.3 * np.random.rand(len(x)) >>> qml.transforms.poly_extrapolate(x, y, 2) tensor(1.01717601, requires_grad=True) """ coeff = _polyfit(x, y, order) return coeff[-1]
[docs]def richardson_extrapolate(x, y): r"""Polynomial fit where the degree of the polynomial is fixed to being equal to the length of ``x``. In a nutshell, this function is calling :func:`~.pennylane.transforms.poly_extrapolate` with ``order = len(x)-1``. This function is compatible with all interfaces supported by pennylane. Args: x (Array): Data in x y (Array): Data in y = f(x) Returns: float: Extrapolated value at f(0). .. seealso:: :func:`~.pennylane.transforms.poly_extrapolate`, :func:`~.pennylane.transforms.mitigate_with_zne` **Example:** >>> x = np.linspace(1, 10, 5) >>> y = x**2 + x + 1 + 0.3 * np.random.rand(len(x)) >>> qml.transforms.richardson_extrapolate(x, y) tensor(1.15105156, requires_grad=True) """ return poly_extrapolate(x, y, len(x) - 1)
# pylint: disable=too-many-arguments, protected-access
[docs]@transform def mitigate_with_zne( tape: QuantumTape, scale_factors: Sequence[float], folding: callable, extrapolate: callable, folding_kwargs: Optional[Dict[str, Any]] = None, extrapolate_kwargs: Optional[Dict[str, Any]] = None, reps_per_factor=1, ) -> (Sequence[QuantumTape], Callable): r"""Mitigate an input circuit using zero-noise extrapolation. Error mitigation is a precursor to error correction and is compatible with near-term quantum devices. It aims to lower the impact of noise when evaluating a circuit on a quantum device by evaluating multiple variations of the circuit and post-processing the results into a noise-reduced estimate. This transform implements the zero-noise extrapolation (ZNE) method originally introduced by `Temme et al. <>`__ and `Li et al. <>`__. Details on the functions passed to the ``folding`` and ``extrapolate`` arguments of this transform can be found in the usage details. This transform is compatible with functionality from the `Mitiq <>`__ package (version 0.11.0 and above), see the example and usage details for further information. Args: tape (QNode or QuantumTape): the quantum circuit to be error-mitigated scale_factors (Sequence[float]): the range of noise scale factors used folding (callable): a function that returns a folded circuit for a specified scale factor extrapolate (callable): a function that returns an extrapolated result when provided a range of scale factors and corresponding results folding_kwargs (dict): optional keyword arguments passed to the ``folding`` function extrapolate_kwargs (dict): optional keyword arguments passed to the ``extrapolate`` function reps_per_factor (int): Number of circuits generated for each scale factor. Useful when the folding function is stochastic. Returns: qnode (QNode) or tuple[List[.QuantumTape], function]: The transformed circuit as described in :func:`qml.transform <pennylane.transform>`. Executing this circuit will provide the mitigated results in the form of a tensor of a tensor, a tuple, or a nested tuple depending upon the nesting structure of measurements in the original circuit. **Example:** We first create a noisy device using ``default.mixed`` by adding :class:`~.AmplitudeDamping` to each gate of circuits executed on the device using the :func:`~.transforms.insert` transform: .. code-block:: python3 import pennylane as qml noise_strength = 0.05 dev = qml.device("default.mixed", wires=2) dev = qml.transforms.insert(qml.AmplitudeDamping, noise_strength)(dev) We can now set up a mitigated QNode by passing a ``folding`` and ``extrapolate`` function. PennyLane provides native functions :func:`~.pennylane.transforms.fold_global` and :func:`~.pennylane.transforms.poly_extrapolate` or :func:`~.pennylane.transforms.richardson_extrapolate` that allow for differentiating through them. Custom functions, as well as functionalities from the `Mitiq <>`__ package are supported as well (see usage details below). .. code-block:: python3 from functools import partial from pennylane import numpy as np from pennylane import qnode from pennylane.transforms import fold_global, poly_extrapolate 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] @partial(qml.transforms.mitigate_with_zne, [1., 2., 3.], fold_global, poly_extrapolate, extrapolate_kwargs={'order': 2}) @qnode(dev) def circuit(w1, w2): qml.SimplifiedTwoDesign(w1, w2, wires=range(2)) return qml.expval(qml.Z(0)) Executions of ``circuit`` will now be mitigated: >>> circuit(w1, w2) 0.19113067083636542 The unmitigated circuit result is ``0.33652776`` while the ideal circuit result is ``0.23688169`` and we can hence see that mitigation has helped reduce our estimation error. This mitigated qnode can be differentiated like any other qnode. >>> qml.grad(circuit)(w1, w2) (array([-0.89319941, 0.37949841]), array([[[-7.04121596e-01, 3.00073104e-01]], [[-6.41155176e-01, 8.32667268e-17]]])) .. details:: :title: Usage Details **Theoretical details** A summary of ZNE can be found in `LaRose et al. <>`__. The method works by assuming that the amount of noise present when a circuit is run on a noisy device is enumerated by a parameter :math:`\gamma`. Suppose we have an input circuit that experiences an amount of noise equal to :math:`\gamma = \gamma_{0}` when executed. Ideally, we would like to evaluate the result of the circuit in the :math:`\gamma = 0` noise-free setting. To do this, we create a family of equivalent circuits whose ideal noise-free value is the same as our input circuit. However, when run on a noisy device, each circuit experiences a noise equal to :math:`\gamma = s \gamma_{0}` for some scale factor :math:`s`. By evaluating the noisy outputs of each circuit, we can extrapolate to :math:`s=0` to estimate the result of running a noise-free circuit. A key element of ZNE is the ability to run equivalent circuits for a range of scale factors :math:`s`. When the noise present in a circuit scales with the number of gates, :math:`s` can be varied using `unitary folding <>`__. Unitary folding works by noticing that a unitary :math:`U` is equivalent to :math:`U U^{\dagger} U`. This type of transform can be applied to individual gates in the circuit or to the whole circuit. When no folding occurs, the scale factor is :math:`s=1` and we are running our input circuit. On the other hand, when each gate has been folded once, we have tripled the amount of noise in the circuit so that :math:`s=3`. For :math:`s \geq 3`, each gate in the circuit will be folded more than once. A typical choice of scale parameters is :math:`(1, 2, 3)`. **Unitary folding** This transform applies ZNE to an input circuit using the unitary folding approach. It requires a callable to be passed as the ``folding`` argument with signature .. code-block:: python fn(circuit, scale_factor, **folding_kwargs) where - ``circuit`` is a quantum tape, - ``scale_factor`` is a float, and - ``folding_kwargs`` are optional keyword arguments. The output of the function should be the folded circuit as a quantum tape. Folding functionality is available from the `Mitiq <>`__ package (version 0.11.0 and above) in the `zne.scaling.folding <>`__ module. .. warning:: Calculating the gradient of mitigated circuits is not supported when using the Mitiq package as a backend for folding or extrapolation. **Extrapolation** This transform also requires a callable to be passed to the ``extrapolate`` argument that returns the extrapolated value(s). Its function should be .. code-block:: python fn(scale_factors, results, **extrapolate_kwargs) where - ``scale_factors`` are the ZNE scale factors, - ``results`` are the execution results of the circuit at the specified scale factors of shape ``(len(scale_factors), len(qnode_returns))``, and - ``extrapolate_kwargs`` are optional keyword arguments. The output of the extrapolate ``fn`` should be a flat array of length ``len(qnode_returns)``. Extrapolation functionality is available using ``extrapolate`` methods of the factories in the `mitiq.zne.inference <>`__ module. """ folding_kwargs = folding_kwargs or {} extrapolate_kwargs = extrapolate_kwargs or {} tape = tape.expand(stop_at=lambda op: not isinstance(op, QuantumScript)) script_removed = QuantumScript(tape.operations[tape.num_preps :]) tapes = [ [folding(script_removed, s, **folding_kwargs) for _ in range(reps_per_factor)] for s in scale_factors ] tapes = [tape_ for tapes_ in tapes for tape_ in tapes_] # flattens nested list # if folding was a batch transform, ignore the processing function if isinstance(tapes[0], tuple) and isinstance(tapes[0][0], list) and callable(tapes[0][1]): tapes = [t[0] for t, _ in tapes] prep_ops = tape.operations[: tape.num_preps] out_tapes = [QuantumScript(prep_ops + tape_.operations, tape.measurements) for tape_ in tapes] def processing_fn(results): """Maps from input tape executions to an error-mitigated estimate""" # content of `results` must be modified in this post-processing function results = list(results) for i, tape in enumerate(out_tapes): # stack the results if there are multiple measurements # this will not create ragged arrays since only expval measurements are allowed if len(tape.observables) > 1: results[i] = qml.math.stack(results[i]) # Averaging over reps_per_factor repetitions results_flattened = [] for i in range(0, len(results), reps_per_factor): # The stacking ensures the right interface is used # averaging over axis=0 is critical because the qnode may have multiple outputs results_flattened.append(mean(qml.math.stack(results[i : i + reps_per_factor]), axis=0)) extrapolated = extrapolate(scale_factors, results_flattened, **extrapolate_kwargs) extrapolated = extrapolated[0] if shape(extrapolated) == (1,) else extrapolated # unstack the results in the case of multiple measurements return extrapolated if shape(extrapolated) == () else tuple(qml.math.unstack(extrapolated)) return out_tapes, processing_fn