qiskit 1.3.0b1__cp39-abi3-macosx_10_9_x86_64.whl

qiskit/result/mitigation/local_readout_mitigator.py

@@ -0,0 +1,320 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+"""
+Readout mitigator class based on the 1-qubit local tensored mitigation method
+"""
+
+
+import math
+from typing import Optional, List, Tuple, Iterable, Callable, Union, Dict
+import numpy as np
+
+from qiskit.exceptions import QiskitError
+from ..distributions.quasi import QuasiDistribution
+from ..counts import Counts
+from .base_readout_mitigator import BaseReadoutMitigator
+from .utils import counts_probability_vector, z_diagonal, str2diag
+
+
+class LocalReadoutMitigator(BaseReadoutMitigator):
+    """1-qubit tensor product readout error mitigator.
+
+    Mitigates :meth:`expectation_value` and :meth:`quasi_probabilities`.
+    The mitigator should either be calibrated using qiskit experiments,
+    or calculated directly from the backend properties.
+    This mitigation method should be used in case the readout errors of the qubits
+    are assumed to be uncorrelated. For *N* qubits there are *N* mitigation matrices,
+    each of size :math:`2 x 2` and the mitigation complexity is :math:`O(2^N)`,
+    so it is more efficient than the :class:`CorrelatedReadoutMitigator` class.
+    """
+
+    def __init__(
+        self,
+        assignment_matrices: Optional[List[np.ndarray]] = None,
+        qubits: Optional[Iterable[int]] = None,
+        backend=None,
+    ):
+        """Initialize a LocalReadoutMitigator
+
+        Args:
+            assignment_matrices: Optional, list of single-qubit readout error assignment matrices.
+            qubits: Optional, the measured physical qubits for mitigation.
+            backend: Optional, backend name.
+
+        Raises:
+            QiskitError: matrices sizes do not agree with number of qubits
+        """
+        if assignment_matrices is None:
+            assignment_matrices = self._from_backend(backend, qubits)
+        else:
+            assignment_matrices = [np.asarray(amat, dtype=float) for amat in assignment_matrices]
+        for amat in assignment_matrices:
+            if np.any(amat < 0) or not np.allclose(np.sum(amat, axis=0), 1):
+                raise QiskitError(
+                    "Assignment matrix columns must be valid probability distributions"
+                )
+        if qubits is None:
+            self._num_qubits = len(assignment_matrices)
+            self._qubits = range(self._num_qubits)
+        else:
+            if len(qubits) != len(assignment_matrices):
+                raise QiskitError(
+                    f"The number of given qubits ({len(qubits)}) is different than the number of qubits "
+                    f"inferred from the matrices ({len(assignment_matrices)})"
+                )
+            self._qubits = qubits
+            self._num_qubits = len(self._qubits)
+
+        self._qubit_index = dict(zip(self._qubits, range(self._num_qubits)))
+        self._assignment_mats = assignment_matrices
+        self._mitigation_mats = np.zeros([self._num_qubits, 2, 2], dtype=float)
+        self._gammas = np.zeros(self._num_qubits, dtype=float)
+
+        for i in range(self._num_qubits):
+            mat = self._assignment_mats[i]
+            # Compute Gamma values
+            error0 = mat[1, 0]
+            error1 = mat[0, 1]
+            self._gammas[i] = (1 + abs(error0 - error1)) / (1 - error0 - error1)
+            # Compute inverse mitigation matrix
+            try:
+                ainv = np.linalg.inv(mat)
+            except np.linalg.LinAlgError:
+                ainv = np.linalg.pinv(mat)
+            self._mitigation_mats[i] = ainv
+
+    @property
+    def settings(self) -> Dict:
+        """Return settings."""
+        return {"assignment_matrices": self._assignment_mats, "qubits": self._qubits}
+
+    def expectation_value(
+        self,
+        data: Counts,
+        diagonal: Union[Callable, dict, str, np.ndarray] = None,
+        qubits: Iterable[int] = None,
+        clbits: Optional[List[int]] = None,
+        shots: Optional[int] = None,
+    ) -> Tuple[float, float]:
+        r"""Compute the mitigated expectation value of a diagonal observable.
+
+        This computes the mitigated estimator of
+        :math:`\langle O \rangle = \mbox{Tr}[\rho. O]` of a diagonal observable
+        :math:`O = \sum_{x\in\{0, 1\}^n} O(x)|x\rangle\!\langle x|`.
+
+        Args:
+            data: Counts object
+            diagonal: Optional, the vector of diagonal values for summing the
+                      expectation value. If ``None`` the default value is
+                      :math:`[1, -1]^\otimes n`.
+            qubits: Optional, the measured physical qubits the count
+                    bitstrings correspond to. If None qubits are assumed to be
+                    :math:`[0, ..., n-1]`.
+            clbits: Optional, if not None marginalize counts to the specified bits.
+            shots: the number of shots.
+
+        Returns:
+            (float, float): the expectation value and an upper bound of the standard deviation.
+
+        Additional Information:
+            The diagonal observable :math:`O` is input using the ``diagonal`` kwarg as
+            a list or Numpy array :math:`[O(0), ..., O(2^n -1)]`. If no diagonal is specified
+            the diagonal of the Pauli operator
+            :math`O = \mbox{diag}(Z^{\otimes n}) = [1, -1]^{\otimes n}` is used.
+            The ``clbits`` kwarg is used to marginalize the input counts dictionary
+            over the specified bit-values, and the ``qubits`` kwarg is used to specify
+            which physical qubits these bit-values correspond to as
+            ``circuit.measure(qubits, clbits)``.
+        """
+        if qubits is None:
+            qubits = self._qubits
+        num_qubits = len(qubits)
+        probs_vec, shots = counts_probability_vector(
+            data, qubit_index=self._qubit_index, clbits=clbits, qubits=qubits
+        )
+
+        # Get qubit mitigation matrix and mitigate probs
+        qubit_indices = [self._qubit_index[qubit] for qubit in qubits]
+        ainvs = self._mitigation_mats[qubit_indices]
+
+        # Get operator coeffs
+        if diagonal is None:
+            diagonal = z_diagonal(2**num_qubits)
+        elif isinstance(diagonal, str):
+            diagonal = str2diag(diagonal)
+
+        # Apply transpose of mitigation matrix
+        coeffs = np.reshape(diagonal, num_qubits * [2])
+        einsum_args = [coeffs, list(range(num_qubits))]
+        for i, ainv in enumerate(reversed(ainvs)):
+            einsum_args += [ainv.T, [num_qubits + i, i]]
+        einsum_args += [list(range(num_qubits, 2 * num_qubits))]
+        coeffs = np.einsum(*einsum_args).ravel()
+
+        expval = coeffs.dot(probs_vec)
+        stddev_upper_bound = self.stddev_upper_bound(shots, qubits)
+
+        return (expval, stddev_upper_bound)
+
+    def quasi_probabilities(
+        self,
+        data: Counts,
+        qubits: Optional[List[int]] = None,
+        clbits: Optional[List[int]] = None,
+        shots: Optional[int] = None,
+    ) -> QuasiDistribution:
+        """Compute mitigated quasi probabilities value.
+
+        Args:
+            data: counts object
+            qubits: qubits the count bitstrings correspond to.
+            clbits: Optional, marginalize counts to just these bits.
+            shots: Optional, the total number of shots, if None shots will
+                be calculated as the sum of all counts.
+
+        Returns:
+            QuasiDistribution: A dictionary containing pairs of [output, mean] where "output"
+                is the key in the dictionaries,
+                which is the length-N bitstring of a measured standard basis state,
+                and "mean" is the mean of non-zero quasi-probability estimates.
+
+        Raises:
+            QiskitError: if qubit and clbit kwargs are not valid.
+        """
+        if qubits is None:
+            qubits = self._qubits
+
+        num_qubits = len(qubits)
+
+        probs_vec, calculated_shots = counts_probability_vector(
+            data, qubit_index=self._qubit_index, clbits=clbits, qubits=qubits
+        )
+        if shots is None:
+            shots = calculated_shots
+
+        # Get qubit mitigation matrix and mitigate probs
+        qubit_indices = [self._qubit_index[qubit] for qubit in qubits]
+        ainvs = self._mitigation_mats[qubit_indices]
+
+        # Apply transpose of mitigation matrix
+        prob_tens = np.reshape(probs_vec, num_qubits * [2])
+        einsum_args = [prob_tens, list(range(num_qubits))]
+        for i, ainv in enumerate(reversed(ainvs)):
+            einsum_args += [ainv, [num_qubits + i, i]]
+        einsum_args += [list(range(num_qubits, 2 * num_qubits))]
+        probs_vec = np.einsum(*einsum_args).ravel()
+
+        probs_dict = {}
+        for index, _ in enumerate(probs_vec):
+            probs_dict[index] = probs_vec[index]
+
+        quasi_dist = QuasiDistribution(
+            probs_dict, shots=shots, stddev_upper_bound=self.stddev_upper_bound(shots, qubits)
+        )
+        return quasi_dist
+
+    def mitigation_matrix(self, qubits: Optional[Union[List[int], int]] = None) -> np.ndarray:
+        r"""Return the measurement mitigation matrix for the specified qubits.
+
+        The mitigation matrix :math:`A^{-1}` is defined as the inverse of the
+        :meth:`assignment_matrix` :math:`A`.
+
+        Args:
+            qubits: Optional, qubits being measured for operator expval.
+                    if a single int is given, it is assumed to be the index
+                    of the qubit in self._qubits
+
+        Returns:
+            np.ndarray: the measurement error mitigation matrix :math:`A^{-1}`.
+        """
+        if qubits is None:
+            qubits = self._qubits
+        if isinstance(qubits, int):
+            qubits = [self._qubits[qubits]]
+        qubit_indices = [self._qubit_index[qubit] for qubit in qubits]
+        mat = self._mitigation_mats[qubit_indices[0]]
+        for i in qubit_indices[1:]:
+            mat = np.kron(self._mitigation_mats[i], mat)
+        return mat
+
+    def assignment_matrix(self, qubits: List[int] = None) -> np.ndarray:
+        r"""Return the measurement assignment matrix for specified qubits.
+
+        The assignment matrix is the stochastic matrix :math:`A` which assigns
+        a noisy measurement probability distribution to an ideal input
+        measurement distribution: :math:`P(i|j) = \langle i | A | j \rangle`.
+
+        Args:
+            qubits: Optional, qubits being measured for operator expval.
+
+        Returns:
+            np.ndarray: the assignment matrix A.
+        """
+        if qubits is None:
+            qubits = self._qubits
+        if isinstance(qubits, int):
+            qubits = [qubits]
+        qubit_indices = [self._qubit_index[qubit] for qubit in qubits]
+        mat = self._assignment_mats[qubit_indices[0]]
+        for i in qubit_indices[1:]:
+            mat = np.kron(self._assignment_mats[i], mat)
+        return mat
+
+    def _compute_gamma(self, qubits=None):
+        """Compute gamma for N-qubit mitigation"""
+        if qubits is None:
+            gammas = self._gammas
+        else:
+            qubit_indices = [self._qubit_index[qubit] for qubit in qubits]
+            gammas = self._gammas[qubit_indices]
+        return np.prod(gammas)
+
+    def stddev_upper_bound(self, shots: int, qubits: List[int] = None):
+        """Return an upper bound on standard deviation of expval estimator.
+
+        Args:
+            shots: Number of shots used for expectation value measurement.
+            qubits: qubits being measured for operator expval.
+
+        Returns:
+            float: the standard deviation upper bound.
+        """
+        gamma = self._compute_gamma(qubits=qubits)
+        return gamma / math.sqrt(shots)
+
+    def _from_backend(self, backend, qubits):
+        """Calculates amats from backend properties readout_error"""
+        backend_qubits = backend.properties().qubits
+        if qubits is not None:
+            if any(qubit >= len(backend_qubits) for qubit in qubits):
+                raise QiskitError("The chosen backend does not contain the specified qubits.")
+            reduced_backend_qubits = [backend_qubits[i] for i in qubits]
+            backend_qubits = reduced_backend_qubits
+        num_qubits = len(backend_qubits)
+
+        amats = np.zeros([num_qubits, 2, 2], dtype=float)
+
+        for qubit_idx, qubit_prop in enumerate(backend_qubits):
+            for prop in qubit_prop:
+                if prop.name == "prob_meas0_prep1":
+                    (amats[qubit_idx])[0, 1] = prop.value
+                    (amats[qubit_idx])[1, 1] = 1 - prop.value
+                if prop.name == "prob_meas1_prep0":
+                    (amats[qubit_idx])[1, 0] = prop.value
+                    (amats[qubit_idx])[0, 0] = 1 - prop.value
+
+        return amats
+
+    @property
+    def qubits(self) -> Tuple[int]:
+        """The device qubits for this mitigator"""
+        return self._qubits

qiskit/result/mitigation/utils.py

@@ -0,0 +1,160 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+"""
+Readout mitigation data handling utils
+"""
+
+import logging
+import math
+from typing import Optional, List, Tuple, Dict
+import numpy as np
+
+from qiskit.exceptions import QiskitError
+from ..utils import marginal_counts
+from ..counts import Counts
+
+logger = logging.getLogger(__name__)
+
+
+def z_diagonal(dim, dtype=float):
+    r"""Return the diagonal for the operator :math:`Z^\otimes n`"""
+    parity = np.zeros(dim, dtype=dtype)
+    for i in range(dim):
+        parity[i] = bin(i)[2:].count("1")
+    return (-1) ** np.mod(parity, 2)
+
+
+def expval_with_stddev(coeffs: np.ndarray, probs: np.ndarray, shots: int) -> Tuple[float, float]:
+    """Compute expectation value and standard deviation.
+    Args:
+        coeffs: array of diagonal operator coefficients.
+        probs: array of measurement probabilities.
+        shots: total number of shots to obtain probabilities.
+    Returns:
+        tuple: (expval, stddev) expectation value and standard deviation.
+    """
+    # Compute expval
+    expval = coeffs.dot(probs)
+
+    # Compute variance
+    sq_expval = (coeffs**2).dot(probs)
+    variance = (sq_expval - expval**2) / shots
+
+    # Compute standard deviation
+    if variance < 0 and not np.isclose(variance, 0):
+        logger.warning(
+            "Encountered a negative variance in expectation value calculation."
+            "(%f). Setting standard deviation of result to 0.",
+            variance,
+        )
+    calc_stddev = math.sqrt(variance) if variance > 0 else 0.0
+    return [expval, calc_stddev]
+
+
+def stddev(probs, shots):
+    """Calculate stddev dict"""
+    ret = {}
+    for key, prob in probs.items():
+        std_err = math.sqrt(prob * (1 - prob) / shots)
+        ret[key] = std_err
+    return ret
+
+
+def str2diag(string):
+    """Transform diagonal from a string to a numpy array"""
+    chars = {
+        "I": np.array([1, 1], dtype=float),
+        "Z": np.array([1, -1], dtype=float),
+        "0": np.array([1, 0], dtype=float),
+        "1": np.array([0, 1], dtype=float),
+    }
+    ret = np.array([1], dtype=float)
+    for i in reversed(string):
+        if i not in chars:
+            raise QiskitError(f"Invalid diagonal string character {i}")
+        ret = np.kron(chars[i], ret)
+    return ret
+
+
+def counts_to_vector(counts: Counts, num_qubits: int) -> Tuple[np.ndarray, int]:
+    """Transforms Counts to a probability vector"""
+    vec = np.zeros(2**num_qubits, dtype=float)
+    shots = 0
+    for key, val in counts.items():
+        shots += val
+        vec[int(key, 2)] = val
+    vec /= shots
+    return vec, shots
+
+
+def remap_qubits(
+    vec: np.ndarray, num_qubits: int, qubits: Optional[List[int]] = None
+) -> np.ndarray:
+    """Remapping the qubits"""
+    if qubits is not None:
+        if len(qubits) != num_qubits:
+            raise QiskitError("Num qubits does not match vector length.")
+        axes = [num_qubits - 1 - i for i in reversed(np.argsort(qubits))]
+        vec = np.reshape(vec, num_qubits * [2]).transpose(axes).reshape(vec.shape)
+    return vec
+
+
+def marganalize_counts(
+    counts: Counts,
+    qubit_index: Dict[int, int],
+    qubits: Optional[List[int]] = None,
+    clbits: Optional[List[int]] = None,
+) -> np.ndarray:
+    """Marginalization of the Counts. Verify that number of clbits equals to the number of qubits."""
+    if clbits is not None:
+        qubits_len = len(qubits) if not qubits is None else 0
+        clbits_len = len(clbits) if not clbits is None else 0
+        if clbits_len not in (0, qubits_len):
+            raise QiskitError(
+                f"Num qubits ({qubits_len}) does not match number of clbits ({clbits_len})."
+            )
+        counts = marginal_counts(counts, clbits)
+    if clbits is None and qubits is not None:
+        clbits = [qubit_index[qubit] for qubit in qubits]
+        counts = marginal_counts(counts, clbits)
+    return counts
+
+
+def counts_probability_vector(
+    counts: Counts,
+    qubit_index: Dict[int, int],
+    qubits: Optional[List[int]] = None,
+    clbits: Optional[List[int]] = None,
+) -> Tuple[np.ndarray, int]:
+    """Compute a probability vector for all count outcomes.
+
+    Args:
+        counts: counts object
+        qubit_index: For each qubit, its index in the mitigator qubits list
+        qubits: qubits the count bitstrings correspond to.
+        clbits: Optional, marginalize counts to just these bits.
+
+    Raises:
+        QiskitError: if qubits and clbits kwargs are not valid.
+
+    Returns:
+        np.ndarray: a probability vector for all count outcomes.
+        int: Number of shots in the counts
+    """
+    counts = marganalize_counts(counts, qubit_index, qubits, clbits)
+    if qubits is not None:
+        num_qubits = len(qubits)
+    else:
+        num_qubits = len(qubit_index.keys())
+    vec, shots = counts_to_vector(counts, num_qubits)
+    vec = remap_qubits(vec, num_qubits, qubits)
+    return vec, shots