11896478377

Committed 18 Nov 2024 04:13PM UTC coverage: 90.496% (-0.7%) from 91.214%

Build # 11896478377

Build Type

push

github

Committed by

web-flow

Commit Message

Cleanup and bugfix to support different primitives. (#55) (#855) (#858)

* Cleanup and bugfix for different primitives support (#55)

* Quick fix and lint for unit tests.

* Fixed a bug in ComputeUncompute and lint corrections.

* Fix formatting for algorithm tests

* Reformatting some variables to make lint compliant.

* Refactor: Cleanup code, preserve existing formatting, apply minor bug fixes, and update missing documentation

* Removing unsupported classes.

* Fix for lint

* Fix lint errors uncovered during workflow checks

* Adjust a unit test to accomodate noise-related variations

(cherry picked from commit 2f7e19cbc)

Co-authored-by: M. Emre Sahin <40424147+OkuyanBoga@users.noreply.github.com>

Run Details

49 of 65 new or added lines in 9 files covered. (75.38%)

10 existing lines in 4 files now uncovered.

4304 of 4756 relevant lines covered (90.5%)

0.9 hits per line

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

95.45

/qiskit_machine_learning/gradients/base/base_estimator_gradient.py

# This code is part of a Qiskit project.
#
# (C) Copyright IBM 2022, 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.

"""
Abstract base class of gradient for ``Estimator``.
"""

from __future__ import annotations

from abc import ABC, abstractmethod
from collections.abc import Sequence
from copy import copy

import numpy as np

from qiskit.circuit import Parameter, ParameterExpression, QuantumCircuit
from qiskit.primitives import BaseEstimator, BaseEstimatorV1
from qiskit.primitives.base import BaseEstimatorV2
from qiskit.primitives.utils import _circuit_key
from qiskit.providers import Options
from qiskit.quantum_info.operators.base_operator import BaseOperator
from qiskit.transpiler.passes import TranslateParameterizedGates
from qiskit.transpiler.passmanager import BasePassManager

from .estimator_gradient_result import EstimatorGradientResult
from ..utils import (
    DerivativeType,
    GradientCircuit,
    _assign_unique_parameters,
    _make_gradient_parameters,
    _make_gradient_parameter_values,
)
from ...utils.deprecation import issue_deprecation_msg
from ...algorithm_job import AlgorithmJob


class BaseEstimatorGradient(ABC):
    """Base class for an ``EstimatorGradient`` to compute the gradients of the expectation value."""

    def __init__(
        self,
        estimator: BaseEstimator | BaseEstimatorV2,
        options: Options | None = None,
        derivative_type: DerivativeType = DerivativeType.REAL,
        pass_manager: BasePassManager | None = None,
    ):
        r"""
        Args:
            estimator: The estimator used to compute the gradients.
            options: Primitive backend runtime options used for circuit execution.
                The order of priority is: options in ``run`` method > gradient's
                default options > primitive's default setting.
                Higher priority setting overrides lower priority setting
            derivative_type: The type of derivative. Can be either ``DerivativeType.REAL``
                ``DerivativeType.IMAG``, or ``DerivativeType.COMPLEX``.

                    - ``DerivativeType.REAL`` computes :math:`2 \mathrm{Re}[⟨ψ(ω)|O(θ)|dω ψ(ω)〉]`.
                    - ``DerivativeType.IMAG`` computes :math:`2 \mathrm{Im}[⟨ψ(ω)|O(θ)|dω ψ(ω)〉]`.
                    - ``DerivativeType.COMPLEX`` computes :math:`2 ⟨ψ(ω)|O(θ)|dω ψ(ω)〉`.

                Defaults to ``DerivativeType.REAL``, as this yields e.g. the commonly-used energy
                gradient and this type is the only supported type for function-level schemes like
                finite difference.
            pass_manager: The pass manager to transpile the circuits if necessary.
            Defaults to ``None``, as some primitives do not need transpiled circuits.
        """
        if isinstance(estimator, BaseEstimatorV1):
            issue_deprecation_msg(
                msg="V1 Primitives are deprecated",
                version="0.8.0",
                remedy="Use V2 primitives for continued compatibility and support.",
                period="4 months",
            )
        self._estimator: BaseEstimator = estimator
        self._pass_manager = pass_manager
        self._default_options = Options()
        if options is not None:
            self._default_options.update_options(**options)
        self._derivative_type = derivative_type

        self._gradient_circuit_cache: dict[
            tuple,
            GradientCircuit,
        ] = {}

    @property
    def derivative_type(self) -> DerivativeType:
        """Return the derivative type (real, imaginary or complex).

        Returns:
            The derivative type.
        """
        return self._derivative_type

    def run(
        self,
        circuits: Sequence[QuantumCircuit],
        observables: Sequence[BaseOperator],
        parameter_values: Sequence[Sequence[float]] | np.ndarray,
        parameters: Sequence[Sequence[Parameter] | None] | None = None,
        **options,
    ) -> AlgorithmJob:
        """Run the job of the estimator gradient on the given circuits.

        Args:
            circuits: The list of quantum circuits to compute the gradients.
            observables: The list of observables.
            parameter_values: The list of parameter values to be bound to the circuit.
            parameters: The sequence of parameters to calculate only the gradients of
                the specified parameters. Each sequence of parameters corresponds to a circuit in
                ``circuits``. Defaults to None, which means that the gradients of all parameters in
                each circuit are calculated. None in the sequence means that the gradients of all
                parameters in the corresponding circuit are calculated.
            options: Primitive backend runtime options used for circuit execution.
                The order of priority is: options in ``run`` method > gradient's
                default options > primitive's default setting.
                Higher priority setting overrides lower priority setting

        Returns:
            The job object of the gradients of the expectation values. The i-th result corresponds to
            ``circuits[i]`` evaluated with parameters bound as ``parameter_values[i]``. The j-th
            element of the i-th result corresponds to the gradient of the i-th circuit with respect
            to the j-th parameter.

        Raises:
            ValueError: Invalid arguments are given.
        """
        if isinstance(circuits, QuantumCircuit):
            # Allow a single circuit to be passed in.
            circuits = (circuits,)
        if isinstance(observables, (BaseOperator)):
            # Allow a single observable to be passed in.
            observables = (observables,)

        if parameters is None:
            # If parameters is None, we calculate the gradients of all parameters in each circuit.
            parameters = [circuit.parameters for circuit in circuits]
        else:
            # If parameters is not None, we calculate the gradients of the specified parameters.
            # None in parameters means that the gradients of all parameters in the corresponding
            # circuit are calculated.
            parameters = [
                params if params is not None else circuits[i].parameters
                for i, params in enumerate(parameters)
            ]
        # Validate the arguments.
        self._validate_arguments(circuits, observables, parameter_values, parameters)
        # The priority of run option is as follows:
        # options in ``run`` method > gradient's default options > primitive's default setting.
        opts = copy(self._default_options)
        opts.update_options(**options)
        # Run the job.
        job = AlgorithmJob(
            self._run, circuits, observables, parameter_values, parameters, **opts.__dict__
        )
        job.submit()
        return job

    @abstractmethod
    def _run(
        self,
        circuits: Sequence[QuantumCircuit],
        observables: Sequence[BaseOperator],
        parameter_values: Sequence[Sequence[float]] | np.ndarray,
        parameters: Sequence[Sequence[Parameter]],
        **options,
    ) -> EstimatorGradientResult:
        """Compute the estimator gradients on the given circuits."""
        raise NotImplementedError()

    def _preprocess(
        self,
        circuits: Sequence[QuantumCircuit],
        parameter_values: Sequence[Sequence[float]] | np.ndarray,
        parameters: Sequence[Sequence[Parameter]],
        supported_gates: Sequence[str],
    ) -> tuple[Sequence[QuantumCircuit], Sequence[Sequence[float]], Sequence[Sequence[Parameter]]]:
        """Preprocess the gradient. This makes a gradient circuit for each circuit. The gradient
        circuit is a transpiled circuit by using the supported gates, and has unique parameters.
        ``parameter_values`` and ``parameters`` are also updated to match the gradient circuit.

        Args:
            circuits: The list of quantum circuits to compute the gradients.
            parameter_values: The list of parameter values to be bound to the circuit.
            parameters: The sequence of parameters to calculate only the gradients of the specified
                parameters.
            supported_gates: The supported gates used to transpile the circuit.

        Returns:
            The list of gradient circuits, the list of parameter values, and the list of parameters.
            parameter_values and parameters are updated to match the gradient circuit.
        """
        translator = TranslateParameterizedGates(supported_gates)
        g_circuits: list[QuantumCircuit] = []
        g_parameter_values: list[Sequence[float]] = []
        g_parameters: list[Sequence[Parameter]] = []
        for circuit, parameter_value_, parameters_ in zip(circuits, parameter_values, parameters):
            circuit_key = _circuit_key(circuit)
            if circuit_key not in self._gradient_circuit_cache:
                unrolled = translator(circuit)
                self._gradient_circuit_cache[circuit_key] = _assign_unique_parameters(unrolled)
            gradient_circuit = self._gradient_circuit_cache[circuit_key]
            g_circuits.append(gradient_circuit.gradient_circuit)
            g_parameter_values.append(
                _make_gradient_parameter_values(  # type: ignore[arg-type]
                    circuit, gradient_circuit, parameter_value_
                )
            )
            g_parameters.append(_make_gradient_parameters(gradient_circuit, parameters_))
        return g_circuits, g_parameter_values, g_parameters

    def _postprocess(
        self,
        results: EstimatorGradientResult,
        circuits: Sequence[QuantumCircuit],
        parameter_values: Sequence[Sequence[float]] | np.ndarray,
        parameters: Sequence[Sequence[Parameter]],
    ) -> EstimatorGradientResult:
        """Postprocess the gradients. This method computes the gradient of the original circuits
        by applying the chain rule to the gradient of the circuits with unique parameters.

        Args:
            results: The computed gradients for the circuits with unique parameters.
            circuits: The list of original circuits submitted for gradient computation.
            parameter_values: The list of parameter values to be bound to the circuits.
            parameters: The sequence of parameters to calculate only the gradients of the specified
                parameters.

        Returns:
            The gradients of the original circuits.
        """
        gradients, metadata = [], []
        for idx, (circuit, parameter_values_, parameters_) in enumerate(
            zip(circuits, parameter_values, parameters)
        ):
            gradient = np.zeros(len(parameters_))
            if (
                "derivative_type" in results.metadata[idx]
                and results.metadata[idx]["derivative_type"] == DerivativeType.COMPLEX
            ):
                # If the derivative type is complex, cast the gradient to complex.
                gradient = gradient.astype("complex")
            gradient_circuit = self._gradient_circuit_cache[_circuit_key(circuit)]
            g_parameters = _make_gradient_parameters(gradient_circuit, parameters_)
            # Make a map from the gradient parameter to the respective index in the gradient.
            g_parameter_indices = {param: i for i, param in enumerate(g_parameters)}
            # Compute the original gradient from the gradient of the gradient circuit
            # by using the chain rule.
            for i, parameter in enumerate(parameters_):
                for g_parameter, coeff in gradient_circuit.parameter_map[parameter]:
                    # Compute the coefficient
                    if isinstance(coeff, ParameterExpression):
                        local_map = {
                            p: parameter_values_[circuit.parameters.data.index(p)]
                            for p in coeff.parameters
                        }
                        bound_coeff = coeff.bind(local_map)
                    else:
                        bound_coeff = coeff
                    # The original gradient is a sum of the gradients of the parameters in the
                    # gradient circuit multiplied by the coefficients.
                    gradient[i] += (
                        float(bound_coeff)
                        * results.gradients[idx][g_parameter_indices[g_parameter]]
                    )
            gradients.append(gradient)
            metadata.append({"parameters": parameters_})
        return EstimatorGradientResult(
            gradients=gradients, metadata=metadata, options=results.options
        )

    @staticmethod
    def _validate_arguments(
        circuits: Sequence[QuantumCircuit],
        observables: Sequence[BaseOperator],
        parameter_values: Sequence[Sequence[float]] | np.ndarray,
        parameters: Sequence[Sequence[Parameter]],
    ) -> None:
        """Validate the arguments of the ``run`` method.

        Args:
            circuits: The list of quantum circuits to compute the gradients.
            observables: The list of observables.
            parameter_values: The list of parameter values to be bound to the circuit.
            parameters: The sequence of parameters to calculate only the gradients of the specified
                parameters.

        Raises:
            ValueError: Invalid arguments are given.
        """
        if len(circuits) != len(parameter_values):
            raise ValueError(
                f"The number of circuits ({len(circuits)}) does not match "
                f"the number of parameter value sets ({len(parameter_values)})."
            )

        for i, (circuit, parameter_value) in enumerate(zip(circuits, parameter_values)):
            if not circuit.num_parameters:
                raise ValueError(f"The {i}-th circuit is not parameterised.")
            if len(parameter_value) != circuit.num_parameters:
                raise ValueError(
                    f"The number of values ({len(parameter_value)}) does not match "
                    f"the number of parameters ({circuit.num_parameters}) for the {i}-th circuit."
                )

        if len(circuits) != len(observables):
            raise ValueError(
                f"The number of circuits ({len(circuits)}) does not match "
                f"the number of observables ({len(observables)})."
            )

        for i, (circuit, observable) in enumerate(zip(circuits, observables)):
            if circuit.num_qubits != observable.num_qubits:
                raise ValueError(
                    f"The number of qubits of the {i}-th circuit ({circuit.num_qubits}) does "
                    f"not match the number of qubits of the {i}-th observable "
                    f"({observable.num_qubits})."
                )

        if len(circuits) != len(parameters):
            raise ValueError(
                f"The number of circuits ({len(circuits)}) does not match "
                f"the number of the list of specified parameters ({len(parameters)})."
            )

        for i, (circuit, parameters_) in enumerate(zip(circuits, parameters)):
            if not set(parameters_).issubset(circuit.parameters):
                raise ValueError(
                    f"The {i}-th parameters contains parameters not present in the "
                    f"{i}-th circuit."
                )

    @property
    def options(self) -> Options:
        """Return the union of estimator options setting and gradient default options,
        where, if the same field is set in both, the gradient's default options override
        the primitive's default setting.

        Returns:
            The gradient default + estimator options.
        """
        return self._get_local_options(self._default_options.__dict__)

    def update_default_options(self, **options):
        """Update the gradient's default options setting.

        Args:
            **options: The fields to update the default options.
        """

        self._default_options.update_options(**options)

    def _get_local_options(self, options: Options) -> Options:
        """Return the union of the primitive's default setting,
        the gradient default options, and the options in the ``run`` method.
        The order of priority is: options in ``run`` method > gradient's
                default options > primitive's default setting.

        Args:
            options: The fields to update the options

        Returns:
            The gradient default + estimator + run options.
        """
        opts = copy(self._estimator.options)
        opts.update_options(**options)
        return opts

1	# This code is part of a Qiskit project.
2	#
3	# (C) Copyright IBM 2022, 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
13	"""
14	Abstract base class of gradient for ``Estimator``.
15	"""
16
17	from __future__ import annotations	1✔
18
19	from abc import ABC, abstractmethod	1✔
20	from collections.abc import Sequence	1✔
21	from copy import copy	1✔
22
23	import numpy as np	1✔
24
25	from qiskit.circuit import Parameter, ParameterExpression, QuantumCircuit	1✔
26	from qiskit.primitives import BaseEstimator, BaseEstimatorV1	1✔
27	from qiskit.primitives.base import BaseEstimatorV2	1✔
28	from qiskit.primitives.utils import _circuit_key	1✔
29	from qiskit.providers import Options	1✔
30	from qiskit.quantum_info.operators.base_operator import BaseOperator	1✔
31	from qiskit.transpiler.passes import TranslateParameterizedGates	1✔
32	from qiskit.transpiler.passmanager import BasePassManager	1✔
33
34	from .estimator_gradient_result import EstimatorGradientResult	1✔
35	from ..utils import (	1✔
36	DerivativeType,
37	GradientCircuit,
38	_assign_unique_parameters,
39	_make_gradient_parameters,
40	_make_gradient_parameter_values,
41	)
42	from ...utils.deprecation import issue_deprecation_msg	1✔
43	from ...algorithm_job import AlgorithmJob	1✔
44
45
46	class BaseEstimatorGradient(ABC):	1✔
47	"""Base class for an ``EstimatorGradient`` to compute the gradients of the expectation value."""
48
49	def __init__(	1✔
50	self,
51	estimator: BaseEstimator \| BaseEstimatorV2,
52	options: Options \| None = None,
53	derivative_type: DerivativeType = DerivativeType.REAL,
54	pass_manager: BasePassManager \| None = None,
55	):
56	r"""
57	Args:
58	estimator: The estimator used to compute the gradients.
59	options: Primitive backend runtime options used for circuit execution.
60	The order of priority is: options in ``run`` method > gradient's
61	default options > primitive's default setting.
62	Higher priority setting overrides lower priority setting
63	derivative_type: The type of derivative. Can be either ``DerivativeType.REAL``
64	``DerivativeType.IMAG``, or ``DerivativeType.COMPLEX``.
65
66	- ``DerivativeType.REAL`` computes :math:`2 \mathrm{Re}[⟨ψ(ω)\|O(θ)\|dω ψ(ω)〉]`.
67	- ``DerivativeType.IMAG`` computes :math:`2 \mathrm{Im}[⟨ψ(ω)\|O(θ)\|dω ψ(ω)〉]`.
68	- ``DerivativeType.COMPLEX`` computes :math:`2 ⟨ψ(ω)\|O(θ)\|dω ψ(ω)〉`.
69
70	Defaults to ``DerivativeType.REAL``, as this yields e.g. the commonly-used energy
71	gradient and this type is the only supported type for function-level schemes like
72	finite difference.
73	pass_manager: The pass manager to transpile the circuits if necessary.
74	Defaults to ``None``, as some primitives do not need transpiled circuits.
75	"""
76	if isinstance(estimator, BaseEstimatorV1):	1✔
77	issue_deprecation_msg(	1✔
78	msg="V1 Primitives are deprecated",
79	version="0.8.0",
80	remedy="Use V2 primitives for continued compatibility and support.",
81	period="4 months",
82	)
83	self._estimator: BaseEstimator = estimator	1✔
84	self._pass_manager = pass_manager	1✔
85	self._default_options = Options()	1✔
86	if options is not None:	1✔
87	self._default_options.update_options(**options)	1✔
88	self._derivative_type = derivative_type	1✔
89
90	self._gradient_circuit_cache: dict[	1✔
91	tuple,
92	GradientCircuit,
93	] = {}
94
95	@property	1✔
96	def derivative_type(self) -> DerivativeType:	1✔
97	"""Return the derivative type (real, imaginary or complex).
98
99	Returns:
100	The derivative type.
101	"""
102	return self._derivative_type	1✔
103
104	def run(	1✔
105	self,
106	circuits: Sequence[QuantumCircuit],
107	observables: Sequence[BaseOperator],
108	parameter_values: Sequence[Sequence[float]] \| np.ndarray,
109	parameters: Sequence[Sequence[Parameter] \| None] \| None = None,
110	**options,
111	) -> AlgorithmJob:
112	"""Run the job of the estimator gradient on the given circuits.
113
114	Args:
115	circuits: The list of quantum circuits to compute the gradients.
116	observables: The list of observables.
117	parameter_values: The list of parameter values to be bound to the circuit.
118	parameters: The sequence of parameters to calculate only the gradients of
119	the specified parameters. Each sequence of parameters corresponds to a circuit in
120	``circuits``. Defaults to None, which means that the gradients of all parameters in
121	each circuit are calculated. None in the sequence means that the gradients of all
122	parameters in the corresponding circuit are calculated.
123	options: Primitive backend runtime options used for circuit execution.
124	The order of priority is: options in ``run`` method > gradient's
125	default options > primitive's default setting.
126	Higher priority setting overrides lower priority setting
127
128	Returns:
129	The job object of the gradients of the expectation values. The i-th result corresponds to
130	``circuits[i]`` evaluated with parameters bound as ``parameter_values[i]``. The j-th
131	element of the i-th result corresponds to the gradient of the i-th circuit with respect
132	to the j-th parameter.
133
134	Raises:
135	ValueError: Invalid arguments are given.
136	"""
137	if isinstance(circuits, QuantumCircuit):	1✔
138	# Allow a single circuit to be passed in.
139	circuits = (circuits,)	1✔
140	if isinstance(observables, (BaseOperator)):	1✔
141	# Allow a single observable to be passed in.
142	observables = (observables,)	1✔
143
144	if parameters is None:	1✔
145	# If parameters is None, we calculate the gradients of all parameters in each circuit.
146	parameters = [circuit.parameters for circuit in circuits]	1✔
147	else:
148	# If parameters is not None, we calculate the gradients of the specified parameters.
149	# None in parameters means that the gradients of all parameters in the corresponding
150	# circuit are calculated.
151	parameters = [	1✔
152	params if params is not None else circuits[i].parameters
153	for i, params in enumerate(parameters)
154	]
155	# Validate the arguments.
156	self._validate_arguments(circuits, observables, parameter_values, parameters)	1✔
157	# The priority of run option is as follows:
158	# options in ``run`` method > gradient's default options > primitive's default setting.
159	opts = copy(self._default_options)	1✔
160	opts.update_options(**options)	1✔
161	# Run the job.
162	job = AlgorithmJob(	1✔
163	self._run, circuits, observables, parameter_values, parameters, **opts.__dict__
164	)
165	job.submit()	1✔
166	return job	1✔
167
168	@abstractmethod	1✔
169	def _run(	1✔
170	self,
171	circuits: Sequence[QuantumCircuit],
172	observables: Sequence[BaseOperator],
173	parameter_values: Sequence[Sequence[float]] \| np.ndarray,
174	parameters: Sequence[Sequence[Parameter]],
175	**options,
176	) -> EstimatorGradientResult:
177	"""Compute the estimator gradients on the given circuits."""
178	raise NotImplementedError()	×
179
180	def _preprocess(	1✔
181	self,
182	circuits: Sequence[QuantumCircuit],
183	parameter_values: Sequence[Sequence[float]] \| np.ndarray,
184	parameters: Sequence[Sequence[Parameter]],
185	supported_gates: Sequence[str],
186	) -> tuple[Sequence[QuantumCircuit], Sequence[Sequence[float]], Sequence[Sequence[Parameter]]]:
187	"""Preprocess the gradient. This makes a gradient circuit for each circuit. The gradient
188	circuit is a transpiled circuit by using the supported gates, and has unique parameters.
189	``parameter_values`` and ``parameters`` are also updated to match the gradient circuit.
190
191	Args:
192	circuits: The list of quantum circuits to compute the gradients.
193	parameter_values: The list of parameter values to be bound to the circuit.
194	parameters: The sequence of parameters to calculate only the gradients of the specified
195	parameters.
196	supported_gates: The supported gates used to transpile the circuit.
197
198	Returns:
199	The list of gradient circuits, the list of parameter values, and the list of parameters.
200	parameter_values and parameters are updated to match the gradient circuit.
201	"""
202	translator = TranslateParameterizedGates(supported_gates)	1✔
203	g_circuits: list[QuantumCircuit] = []	1✔
204	g_parameter_values: list[Sequence[float]] = []	1✔
205	g_parameters: list[Sequence[Parameter]] = []	1✔
206	for circuit, parameter_value_, parameters_ in zip(circuits, parameter_values, parameters):	1✔
207	circuit_key = _circuit_key(circuit)	1✔
208	if circuit_key not in self._gradient_circuit_cache:	1✔
209	unrolled = translator(circuit)	1✔
210	self._gradient_circuit_cache[circuit_key] = _assign_unique_parameters(unrolled)	1✔
211	gradient_circuit = self._gradient_circuit_cache[circuit_key]	1✔
212	g_circuits.append(gradient_circuit.gradient_circuit)	1✔
213	g_parameter_values.append(	1✔
214	_make_gradient_parameter_values( # type: ignore[arg-type]
215	circuit, gradient_circuit, parameter_value_
216	)
217	)
218	g_parameters.append(_make_gradient_parameters(gradient_circuit, parameters_))	1✔
219	return g_circuits, g_parameter_values, g_parameters	1✔
220
221	def _postprocess(	1✔
222	self,
223	results: EstimatorGradientResult,
224	circuits: Sequence[QuantumCircuit],
225	parameter_values: Sequence[Sequence[float]] \| np.ndarray,
226	parameters: Sequence[Sequence[Parameter]],
227	) -> EstimatorGradientResult:
228	"""Postprocess the gradients. This method computes the gradient of the original circuits
229	by applying the chain rule to the gradient of the circuits with unique parameters.
230
231	Args:
232	results: The computed gradients for the circuits with unique parameters.
233	circuits: The list of original circuits submitted for gradient computation.
234	parameter_values: The list of parameter values to be bound to the circuits.
235	parameters: The sequence of parameters to calculate only the gradients of the specified
236	parameters.
237
238	Returns:
239	The gradients of the original circuits.
240	"""
241	gradients, metadata = [], []	1✔
242	for idx, (circuit, parameter_values_, parameters_) in enumerate(	1✔
243	zip(circuits, parameter_values, parameters)
244	):
245	gradient = np.zeros(len(parameters_))	1✔
246	if (	1✔
247	"derivative_type" in results.metadata[idx]
248	and results.metadata[idx]["derivative_type"] == DerivativeType.COMPLEX
249	):
250	# If the derivative type is complex, cast the gradient to complex.
UNCOV 251	gradient = gradient.astype("complex")	×
252	gradient_circuit = self._gradient_circuit_cache[_circuit_key(circuit)]	1✔
253	g_parameters = _make_gradient_parameters(gradient_circuit, parameters_)	1✔
254	# Make a map from the gradient parameter to the respective index in the gradient.
255	g_parameter_indices = {param: i for i, param in enumerate(g_parameters)}	1✔
256	# Compute the original gradient from the gradient of the gradient circuit
257	# by using the chain rule.
258	for i, parameter in enumerate(parameters_):	1✔
259	for g_parameter, coeff in gradient_circuit.parameter_map[parameter]:	1✔
260	# Compute the coefficient
261	if isinstance(coeff, ParameterExpression):	1✔
262	local_map = {	1✔
263	p: parameter_values_[circuit.parameters.data.index(p)]
264	for p in coeff.parameters
265	}
266	bound_coeff = coeff.bind(local_map)	1✔
267	else:
268	bound_coeff = coeff	1✔
269	# The original gradient is a sum of the gradients of the parameters in the
270	# gradient circuit multiplied by the coefficients.
271	gradient[i] += (	1✔
272	float(bound_coeff)
273	* results.gradients[idx][g_parameter_indices[g_parameter]]
274	)
275	gradients.append(gradient)	1✔
276	metadata.append({"parameters": parameters_})	1✔
277	return EstimatorGradientResult(	1✔
278	gradients=gradients, metadata=metadata, options=results.options
279	)
280
281	@staticmethod	1✔
282	def _validate_arguments(	1✔
283	circuits: Sequence[QuantumCircuit],
284	observables: Sequence[BaseOperator],
285	parameter_values: Sequence[Sequence[float]] \| np.ndarray,
286	parameters: Sequence[Sequence[Parameter]],
287	) -> None:
288	"""Validate the arguments of the ``run`` method.
289
290	Args:
291	circuits: The list of quantum circuits to compute the gradients.
292	observables: The list of observables.
293	parameter_values: The list of parameter values to be bound to the circuit.
294	parameters: The sequence of parameters to calculate only the gradients of the specified
295	parameters.
296
297	Raises:
298	ValueError: Invalid arguments are given.
299	"""
300	if len(circuits) != len(parameter_values):	1✔
301	raise ValueError(	1✔
302	f"The number of circuits ({len(circuits)}) does not match "
303	f"the number of parameter value sets ({len(parameter_values)})."
304	)
305
306	for i, (circuit, parameter_value) in enumerate(zip(circuits, parameter_values)):	1✔
307	if not circuit.num_parameters:	1✔
308	raise ValueError(f"The {i}-th circuit is not parameterised.")	×
309	if len(parameter_value) != circuit.num_parameters:	1✔
310	raise ValueError(	1✔
311	f"The number of values ({len(parameter_value)}) does not match "
312	f"the number of parameters ({circuit.num_parameters}) for the {i}-th circuit."
313	)
314
315	if len(circuits) != len(observables):	1✔
316	raise ValueError(	1✔
317	f"The number of circuits ({len(circuits)}) does not match "
318	f"the number of observables ({len(observables)})."
319	)
320
321	for i, (circuit, observable) in enumerate(zip(circuits, observables)):	1✔
322	if circuit.num_qubits != observable.num_qubits:	1✔
323	raise ValueError(	×
324	f"The number of qubits of the {i}-th circuit ({circuit.num_qubits}) does "
325	f"not match the number of qubits of the {i}-th observable "
326	f"({observable.num_qubits})."
327	)
328
329	if len(circuits) != len(parameters):	1✔
330	raise ValueError(	1✔
331	f"The number of circuits ({len(circuits)}) does not match "
332	f"the number of the list of specified parameters ({len(parameters)})."
333	)
334
335	for i, (circuit, parameters_) in enumerate(zip(circuits, parameters)):	1✔
336	if not set(parameters_).issubset(circuit.parameters):	1✔
337	raise ValueError(	×
338	f"The {i}-th parameters contains parameters not present in the "
339	f"{i}-th circuit."
340	)
341
342	@property	1✔
343	def options(self) -> Options:	1✔
344	"""Return the union of estimator options setting and gradient default options,
345	where, if the same field is set in both, the gradient's default options override
346	the primitive's default setting.
347
348	Returns:
349	The gradient default + estimator options.
350	"""
351	return self._get_local_options(self._default_options.__dict__)	1✔
352
353	def update_default_options(self, **options):	1✔
354	"""Update the gradient's default options setting.
355
356	Args:
357	**options: The fields to update the default options.
358	"""
359
360	self._default_options.update_options(**options)	1✔
361
362	def _get_local_options(self, options: Options) -> Options:	1✔
363	"""Return the union of the primitive's default setting,
364	the gradient default options, and the options in the ``run`` method.
365	The order of priority is: options in ``run`` method > gradient's
366	default options > primitive's default setting.
367
368	Args:
369	options: The fields to update the options
370
371	Returns:
372	The gradient default + estimator + run options.
373	"""
374	opts = copy(self._estimator.options)	1✔
375	opts.update_options(**options)	1✔
376	return opts	1✔

qiskit-community / qiskit-machine-learning / 11896478377

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