8090622088

Committed 29 Feb 2024 03:31AM UTC coverage: 89.301% (+0.03%) from 89.271%

Build # 8090622088

Build Type

push

github

Committed by

web-flow

Commit Message

fix type hint and doc (#11910) (#11918)

(cherry picked from commit 8acc76606)

Co-authored-by: Takashi Imamichi <31178928+t-imamichi@users.noreply.github.com>

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

3 existing lines in 2 files now uncovered.

58913 of 65971 relevant lines covered (89.3%)

186499.18 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.55

/qiskit/primitives/statevector_estimator.py

# This code is part of Qiskit.
#
# (C) Copyright IBM 2023, 2024.
#
# 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.
"""
Estimator class
"""

from __future__ import annotations

from collections.abc import Iterable

import numpy as np

from qiskit.quantum_info import SparsePauliOp, Statevector

from .base import BaseEstimatorV2
from .containers import EstimatorPubLike, PrimitiveResult, PubResult
from .containers.estimator_pub import EstimatorPub
from .primitive_job import PrimitiveJob
from .utils import bound_circuit_to_instruction


class StatevectorEstimator(BaseEstimatorV2):
    """
    Simple implementation of :class:`BaseEstimatorV2` with full state vector simulation.

    This class is implemented via :class:`~.Statevector` which turns provided circuits into
    pure state vectors. These states are subsequently acted on by :class:~.SparsePauliOp`,
    which implies that, at present, this implementation is only compatible with Pauli-based
    observables.

    Each tuple of ``(circuit, observables, <optional> parameter values, <optional> precision)``,
    called an estimator primitive unified bloc (PUB), produces its own array-based result. The
    :meth:`~.EstimatorV2.run` method can be given a sequence of pubs to run in one call.

    .. plot::
        :include-source:

        from qiskit.circuit import Parameter, QuantumCircuit
        from qiskit.primitives import StatevectorEstimator
        from qiskit.quantum_info import Pauli, SparsePauliOp

        import matplotlib.pyplot as plt
        import numpy as np

        # Define a circuit with two parameters.
        circuit = QuantumCircuit(2)
        circuit.h(0)
        circuit.cx(0, 1)
        circuit.ry(Parameter("a"), 0)
        circuit.rz(Parameter("b"), 0)
        circuit.cx(0, 1)
        circuit.h(0)

        # Define a sweep over parameter values, where the second axis is over
        # the two parameters in the circuit.
        params = np.vstack([
            np.linspace(-np.pi, np.pi, 100),
            np.linspace(-4 * np.pi, 4 * np.pi, 100)
        ]).T

        # Define three observables. Many formats are supported here including
        # classes such as qiskit.quantum_info.SparsePauliOp. The inner length-1
        # lists cause this array of observables to have shape (3, 1), rather
        # than shape (3,) if they were omitted.
        observables = [
            [SparsePauliOp(["XX", "IY"], [0.5, 0.5])],
            [Pauli("XX")],
            [Pauli("IY")]
        ]

        # Instantiate a new statevector simulation based estimator object.
        estimator = StatevectorEstimator()

        # Estimate the expectation value for all 300 combinations of
        # observables and parameter values, where the pub result will have
        # shape (3, 100). This shape is due to our array of parameter
        # bindings having shape (100,), combined with our array of observables
        # having shape (3, 1)
        pub = (circuit, observables, params)
        job = estimator.run([pub])

        # Extract the result for the 0th pub (this example only has one pub).
        result = job.result()[0]

        # Error-bar information is also available, but the error is 0
        # for this StatevectorEstimator.
        result.data.stds

        # Pull out the array-based expectation value estimate data from the
        # result and plot a trace for each observable.
        for idx, pauli in enumerate(observables):
            plt.plot(result.data.evs[idx], label=pauli)
        plt.legend()
    """

    def __init__(
        self, *, default_precision: float = 0.0, seed: np.random.Generator | int | None = None
    ):
        """
        Args:
            default_precision: The default precision for the estimator if not specified during run.
            seed: The seed or Generator object for random number generation.
                If None, a random seeded default RNG will be used.
        """
        self._default_precision = default_precision
        self._seed = seed

    @property
    def default_precision(self) -> float:
        """Return the default precision"""
        return self._default_precision

    @property
    def seed(self) -> np.random.Generator | int | None:
        """Return the seed or Generator object for random number generation."""
        return self._seed

    def run(
        self, pubs: Iterable[EstimatorPubLike], *, precision: float | None = None
    ) -> PrimitiveJob[PrimitiveResult[PubResult]]:
        if precision is None:
            precision = self._default_precision
        coerced_pubs = [EstimatorPub.coerce(pub, precision) for pub in pubs]

        job = PrimitiveJob(self._run, coerced_pubs)
        job._submit()
        return job

    def _run(self, pubs: list[EstimatorPub]) -> PrimitiveResult[PubResult]:
        return PrimitiveResult([self._run_pub(pub) for pub in pubs])

    def _run_pub(self, pub: EstimatorPub) -> PubResult:
        rng = np.random.default_rng(self._seed)
        circuit = pub.circuit
        observables = pub.observables
        parameter_values = pub.parameter_values
        precision = pub.precision
        bound_circuits = parameter_values.bind_all(circuit)
        bc_circuits, bc_obs = np.broadcast_arrays(bound_circuits, observables)
        evs = np.zeros_like(bc_circuits, dtype=np.float64)
        stds = np.zeros_like(bc_circuits, dtype=np.float64)
        for index in np.ndindex(*bc_circuits.shape):
            bound_circuit = bc_circuits[index]
            observable = bc_obs[index]
            final_state = Statevector(bound_circuit_to_instruction(bound_circuit))
            paulis, coeffs = zip(*observable.items())
            obs = SparsePauliOp(paulis, coeffs)  # TODO: support non Pauli operators
            expectation_value = np.real_if_close(final_state.expectation_value(obs))
            if precision != 0:
                if not np.isreal(expectation_value):
                    raise ValueError("Given operator is not Hermitian and noise cannot be added.")
                expectation_value = rng.normal(expectation_value, precision)
            evs[index] = expectation_value
        data_bin_cls = self._make_data_bin(pub)
        data_bin = data_bin_cls(evs=evs, stds=stds)
        return PubResult(data_bin, metadata={"precision": precision})

1	# This code is part of Qiskit.
2	#
3	# (C) Copyright IBM 2023, 2024.
4	#
5	# This code is licensed under the Apache License, Version 2.0. You may
6	# obtain a copy of this license in the LICENSE.txt file in the root directory
7	# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
8	#
9	# Any modifications or derivative works of this code must retain this
10	# copyright notice, and modified files need to carry a notice indicating
11	# that they have been altered from the originals.
12	"""	1✔
13	Estimator class
14	"""
15
16	from __future__ import annotations	1✔
17
18	from collections.abc import Iterable	1✔
19
20	import numpy as np	1✔
21
22	from qiskit.quantum_info import SparsePauliOp, Statevector	1✔
23
24	from .base import BaseEstimatorV2	1✔
25	from .containers import EstimatorPubLike, PrimitiveResult, PubResult	1✔
26	from .containers.estimator_pub import EstimatorPub	1✔
27	from .primitive_job import PrimitiveJob	1✔
28	from .utils import bound_circuit_to_instruction	1✔
29
30
31	class StatevectorEstimator(BaseEstimatorV2):	1✔
32	"""	1✔
33	Simple implementation of :class:`BaseEstimatorV2` with full state vector simulation.
34
35	This class is implemented via :class:`~.Statevector` which turns provided circuits into
36	pure state vectors. These states are subsequently acted on by :class:~.SparsePauliOp`,
37	which implies that, at present, this implementation is only compatible with Pauli-based
38	observables.
39
40	Each tuple of ``(circuit, observables, <optional> parameter values, <optional> precision)``,
41	called an estimator primitive unified bloc (PUB), produces its own array-based result. The
42	:meth:`~.EstimatorV2.run` method can be given a sequence of pubs to run in one call.
43
44	.. plot::
45	:include-source:
46
47	from qiskit.circuit import Parameter, QuantumCircuit
48	from qiskit.primitives import StatevectorEstimator
49	from qiskit.quantum_info import Pauli, SparsePauliOp
50
51	import matplotlib.pyplot as plt
52	import numpy as np
53
54	# Define a circuit with two parameters.
55	circuit = QuantumCircuit(2)
56	circuit.h(0)
57	circuit.cx(0, 1)
58	circuit.ry(Parameter("a"), 0)
59	circuit.rz(Parameter("b"), 0)
60	circuit.cx(0, 1)
61	circuit.h(0)
62
63	# Define a sweep over parameter values, where the second axis is over
64	# the two parameters in the circuit.
65	params = np.vstack([
66	np.linspace(-np.pi, np.pi, 100),
67	np.linspace(-4 * np.pi, 4 * np.pi, 100)
68	]).T
69
70	# Define three observables. Many formats are supported here including
71	# classes such as qiskit.quantum_info.SparsePauliOp. The inner length-1
72	# lists cause this array of observables to have shape (3, 1), rather
73	# than shape (3,) if they were omitted.
74	observables = [
75	[SparsePauliOp(["XX", "IY"], [0.5, 0.5])],
76	[Pauli("XX")],
77	[Pauli("IY")]
78	]
79
80	# Instantiate a new statevector simulation based estimator object.
81	estimator = StatevectorEstimator()
82
83	# Estimate the expectation value for all 300 combinations of
84	# observables and parameter values, where the pub result will have
85	# shape (3, 100). This shape is due to our array of parameter
86	# bindings having shape (100,), combined with our array of observables
87	# having shape (3, 1)
88	pub = (circuit, observables, params)
89	job = estimator.run([pub])
90
91	# Extract the result for the 0th pub (this example only has one pub).
92	result = job.result()[0]
93
94	# Error-bar information is also available, but the error is 0
95	# for this StatevectorEstimator.
96	result.data.stds
97
98	# Pull out the array-based expectation value estimate data from the
99	# result and plot a trace for each observable.
100	for idx, pauli in enumerate(observables):
101	plt.plot(result.data.evs[idx], label=pauli)
102	plt.legend()
103	"""
104
105	def __init__(	1✔
106	self, *, default_precision: float = 0.0, seed: np.random.Generator \| int \| None = None
107	):
108	"""
109	Args:
110	default_precision: The default precision for the estimator if not specified during run.
111	seed: The seed or Generator object for random number generation.
112	If None, a random seeded default RNG will be used.
113	"""
114	self._default_precision = default_precision	1✔
115	self._seed = seed	1✔
116
117	@property	1✔
118	def default_precision(self) -> float:	1✔
119	"""Return the default precision"""
UNCOV 120	return self._default_precision	×
121
122	@property	1✔
123	def seed(self) -> np.random.Generator \| int \| None:	1✔
124	"""Return the seed or Generator object for random number generation."""
125	return self._seed	×
126
127	def run(	1✔
128	self, pubs: Iterable[EstimatorPubLike], *, precision: float \| None = None
129	) -> PrimitiveJob[PrimitiveResult[PubResult]]:
130	if precision is None:	1✔
131	precision = self._default_precision	1✔
132	coerced_pubs = [EstimatorPub.coerce(pub, precision) for pub in pubs]	1✔
133
134	job = PrimitiveJob(self._run, coerced_pubs)	1✔
135	job._submit()	1✔
136	return job	1✔
137
138	def _run(self, pubs: list[EstimatorPub]) -> PrimitiveResult[PubResult]:	1✔
139	return PrimitiveResult([self._run_pub(pub) for pub in pubs])	1✔
140
141	def _run_pub(self, pub: EstimatorPub) -> PubResult:	1✔
142	rng = np.random.default_rng(self._seed)	1✔
143	circuit = pub.circuit	1✔
144	observables = pub.observables	1✔
145	parameter_values = pub.parameter_values	1✔
146	precision = pub.precision	1✔
147	bound_circuits = parameter_values.bind_all(circuit)	1✔
148	bc_circuits, bc_obs = np.broadcast_arrays(bound_circuits, observables)	1✔
149	evs = np.zeros_like(bc_circuits, dtype=np.float64)	1✔
150	stds = np.zeros_like(bc_circuits, dtype=np.float64)	1✔
151	for index in np.ndindex(*bc_circuits.shape):	1✔
152	bound_circuit = bc_circuits[index]	1✔
153	observable = bc_obs[index]	1✔
154	final_state = Statevector(bound_circuit_to_instruction(bound_circuit))	1✔
155	paulis, coeffs = zip(*observable.items())	1✔
156	obs = SparsePauliOp(paulis, coeffs) # TODO: support non Pauli operators	1✔
157	expectation_value = np.real_if_close(final_state.expectation_value(obs))	1✔
158	if precision != 0:	1✔
159	if not np.isreal(expectation_value):	1✔
160	raise ValueError("Given operator is not Hermitian and noise cannot be added.")	×
161	expectation_value = rng.normal(expectation_value, precision)	1✔
162	evs[index] = expectation_value	1✔
163	data_bin_cls = self._make_data_bin(pub)	1✔
164	data_bin = data_bin_cls(evs=evs, stds=stds)	1✔
165	return PubResult(data_bin, metadata={"precision": precision})	1✔

Qiskit / qiskit / 8090622088

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous