transpile ansatz and pauli-lists separately in VQE

qiskit/algorithms/minimum_eigen_solvers/vqe.py

@@ -9,41 +9,41 @@
 # 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.
-
 """The Variational Quantum Eigensolver algorithm.
 
 See https://arxiv.org/abs/1304.3061
 """
 
-from typing import Optional, List, Callable, Union, Dict, Tuple
 import logging
 import warnings
 from time import time
+from typing import Callable, Dict, List, Optional, Tuple, Union
+
 import numpy as np
 
-from qiskit.circuit import QuantumCircuit, Parameter
+from qiskit.circuit import Parameter, QuantumCircuit
 from qiskit.circuit.library import RealAmplitudes
-from qiskit.providers import BaseBackend
-from qiskit.providers import Backend
 from qiskit.opflow import (
-    OperatorBase,
+    CircuitSampler,
+    CircuitStateFn,
     ExpectationBase,
     ExpectationFactory,
-    StateFn,
-    CircuitStateFn,
-    ListOp,
     I,
-    CircuitSampler,
+    ListOp,
+    OperatorBase,
+    StateFn,
 )
 from qiskit.opflow.gradients import GradientBase
-from qiskit.utils.validation import validate_min
+from qiskit.providers import Backend, BaseBackend
+from qiskit.utils import QuantumInstance, algorithm_globals
 from qiskit.utils.backend_utils import is_aer_provider
 from qiskit.utils.deprecation import deprecate_function
-from qiskit.utils import QuantumInstance, algorithm_globals
-from ..optimizers import Optimizer, SLSQP
+from qiskit.utils.validation import validate_min
+
+from ..exceptions import AlgorithmError
+from ..optimizers import SLSQP, Optimizer
 from ..variational_algorithm import VariationalAlgorithm, VariationalResult
 from .minimum_eigen_solver import MinimumEigensolver, MinimumEigensolverResult
-from ..exceptions import AlgorithmError
 
 logger = logging.getLogger(__name__)
 
@@ -97,6 +97,7 @@ def __init__(
         max_evals_grouped: int = 1,
         callback: Optional[Callable[[int, np.ndarray, float, float], None]] = None,
         quantum_instance: Optional[Union[QuantumInstance, BaseBackend, Backend]] = None,
+        split_transpile: bool = True,
         sort_parameters_by_name: Optional[bool] = None,
     ) -> None:
         """
@@ -133,6 +134,8 @@ def __init__(
                 These are: the evaluation count, the optimizer parameters for the
                 ansatz, the evaluated mean and the evaluated standard deviation.`
             quantum_instance: Quantum Instance or Backend
+            split_transpile: ``True`` allows transpiling circuits for ansatz and expectation
+                separately.
             sort_parameters_by_name: Deprecated. If True, the initial point is bound to the ansatz
                 parameters strictly sorted by name instead of the default circuit order. That means
                 that the ansatz parameters are e.g. sorted as ``x[0] x[1] x[10] x[2] ...`` instead
@@ -166,6 +169,7 @@ def __init__(
         self._circuit_sampler = None  # type: Optional[CircuitSampler]
         self._expectation = expectation
         self._include_custom = include_custom
+        self._split_transpile = split_transpile
 
         # set ansatz -- still supporting pre 0.18.0 sorting
         self._sort_parameters_by_name = sort_parameters_by_name
@@ -235,7 +239,9 @@ def quantum_instance(
             quantum_instance = QuantumInstance(quantum_instance)
         self._quantum_instance = quantum_instance
         self._circuit_sampler = CircuitSampler(
-            quantum_instance, param_qobj=is_aer_provider(quantum_instance.backend)
+            quantum_instance,
+            param_qobj=is_aer_provider(quantum_instance.backend),
+            split_transpile=self._split_transpile,
         )
 
     @property
@@ -367,7 +373,7 @@ def construct_expectation(
 
         observable_meas = expectation.convert(StateFn(operator, is_measurement=True))
         ansatz_circuit_op = CircuitStateFn(wave_function)
-        expect_op = observable_meas.compose(ansatz_circuit_op).reduce()
+        expect_op = observable_meas.compose(ansatz_circuit_op)
 
         if return_expectation:
             return expect_op, expectation
@@ -416,7 +422,7 @@ def _eval_aux_ops(
         threshold: float = 1e-12,
     ) -> np.ndarray:
         # Create new CircuitSampler to avoid breaking existing one's caches.
-        sampler = CircuitSampler(self.quantum_instance)
+        sampler = CircuitSampler(self.quantum_instance, split_transpile=self._split_transpile)
 
         aux_op_meas = expectation.convert(StateFn(ListOp(aux_operators), is_measurement=True))
         aux_op_expect = aux_op_meas.compose(CircuitStateFn(self.ansatz.bind_parameters(parameters)))

qiskit/opflow/converters/circuit_sampler.py

@@ -24,6 +24,7 @@
 from qiskit.circuit import Parameter, ParameterExpression, QuantumCircuit
 from qiskit.opflow.converters.converter_base import ConverterBase
 from qiskit.opflow.exceptions import OpflowError
+from qiskit.opflow.list_ops.composed_op import ComposedOp
 from qiskit.opflow.list_ops.list_op import ListOp
 from qiskit.opflow.operator_base import OperatorBase
 from qiskit.opflow.state_fns.circuit_state_fn import CircuitStateFn
@@ -58,6 +59,7 @@ def __init__(
         param_qobj: bool = False,
         attach_results: bool = False,
         caching: str = "last",
+        split_transpile: bool = True,
     ) -> None:
         """
         Args:
@@ -72,6 +74,8 @@ def __init__(
                 the circuits.
             caching: The caching strategy. Can be `'last'` (default) to store the last operator
                 that was converted, set to `'all'` to cache all processed operators.
+            split_transpile: ``True`` allows transpiling circuits for ansatz and expectation
+                separately.
 
         Raises:
             ValueError: Set statevector or param_qobj True when not supported by backend.
@@ -99,6 +103,7 @@ def __init__(
         self._transpiled_circ_cache: Optional[List[Any]] = None
         self._transpiled_circ_templates: Optional[List[Any]] = None
         self._transpile_before_bind = True
+        self._split_transpile = split_transpile
 
     def _check_quantum_instance_and_modes_consistent(self) -> None:
         """Checks whether the statevector and param_qobj settings are compatible with the
@@ -172,20 +177,93 @@ def convert(
             if self._caching == "last":
                 self.clear_cache()
 
-            # convert to circuit and reduce
-            operator_dicts_replaced = operator.to_circuit_op()
-            self._reduced_op_cache = operator_dicts_replaced.reduce()
-
-            # extract circuits
-            self._circuit_ops_cache = {}
-            self._extract_circuitstatefns(self._reduced_op_cache)
-            if not self._circuit_ops_cache:
-                raise OpflowError(
-                    "Circuits are empty. "
-                    "Check that the operator is an instance of CircuitStateFn or its ListOp."
-                )
-            self._transpiled_circ_cache = None
-            self._transpile_before_bind = True
+            if (
+                self._split_transpile
+                and isinstance(operator, ComposedOp)
+                and len(operator) == 2
+                and isinstance(operator[1], CircuitStateFn)
+            ):
+                self._reduced_op_cache = operator.to_circuit_op().reduce()
+                self._circuit_ops_cache = {}
+                self._extract_circuitstatefns(self._reduced_op_cache)
+                if not self._circuit_ops_cache:
+                    raise OpflowError(
+                        "Circuits are empty. "
+                        "Check that the operator is an instance of CircuitStateFn or its ListOp."
+                    )
+                circuits = [
+                    op_c.to_circuit(meas=not self._statevector)
+                    for op_c in list(self._circuit_ops_cache.values())
+                ]
+
+                common_circuit = operator[1].to_circuit_op().reduce().to_circuit()
+                try:
+                    # 1. transpile a common circuit
+                    transpiled_common_circuit = self.quantum_instance.transpile(common_circuit)[0]
+
+                    # 2. transpile diff circuits
+                    diff_circuits = []
+                    for circuit in circuits:
+                        diff_circuit = circuit.copy()
+                        del diff_circuit.data[0 : len(common_circuit)]
+                        diff_circuits.append(diff_circuit)
+
+                    if transpiled_common_circuit._layout is not None:
+                        layout = transpiled_common_circuit._layout.copy()
+                        used_qubits = set(
+                            used_qubit
+                            for diff_circuit in diff_circuits
+                            for used_qubit in diff_circuit.qubits
+                        )
+                        for q in list(layout.get_virtual_bits().keys()):
+                            if q not in used_qubits:
+                                del layout[q]
+                        orig_layout = self.quantum_instance.compile_config["initial_layout"]
+                        self.quantum_instance.compile_config["initial_layout"] = layout
+
+                    diff_circuits = self.quantum_instance.transpile(diff_circuits)
+
+                    if transpiled_common_circuit._layout is not None:
+                        self.quantum_instance.compile_config["initial_layout"] = orig_layout
+
+                    # 3. combine
+                    transpiled_circuits = []
+                    for diff_circuit in diff_circuits:
+                        transpiled_circuit = transpiled_common_circuit.copy()
+                        for creg in diff_circuit.cregs:
+                            if creg not in transpiled_circuit.cregs:
+                                transpiled_circuit.add_register(creg)
+                        for inst, qargs, cargs in diff_circuit.data:
+                            transpiled_circuit.append(inst, qargs, cargs)
+                        transpiled_circuits.append(transpiled_circuit)
+
+                    # 4. set transpiled circuit cache
+                    self._transpiled_circ_cache = transpiled_circuits
+                    self._transpile_before_bind = True
+                except QiskitError:
+                    logger.debug(
+                        r"CircuitSampler failed to transpile circuits with unbound "
+                        r"parameters. Attempting to transpile only when circuits are bound "
+                        r"now, but this can hurt performance due to repeated transpilation."
+                    )
+                    self._transpile_before_bind = False
+                    self._transpiled_circ_cache = circuits
+            else:
+                # convert to circuit and reduce
+                operator_dicts_replaced = operator.to_circuit_op()
+                self._reduced_op_cache = operator_dicts_replaced.reduce()
+
+                # extract circuits
+                self._circuit_ops_cache = {}
+                self._extract_circuitstatefns(self._reduced_op_cache)
+                if not self._circuit_ops_cache:
+                    raise OpflowError(
+                        "Circuits are empty. "
+                        "Check that the operator is an instance of CircuitStateFn or its ListOp."
+                    )
+
+                self._transpiled_circ_cache = None
+                self._transpile_before_bind = True
         else:
             # load the cached circuits
             self._reduced_op_cache = self._cached_ops[op_id].reduced_op_cache

qiskit/transpiler/layout.py

@@ -123,11 +123,11 @@ def _set_type_checked_item(self, virtual, physical):
 
     def __delitem__(self, key):
         if isinstance(key, int):
-            del self._p2v[key]
             del self._v2p[self._p2v[key]]
+            del self._p2v[key]
         elif isinstance(key, Qubit):
-            del self._v2p[key]
             del self._p2v[self._v2p[key]]
+            del self._v2p[key]
         else:
             raise LayoutError(
                 "The key to remove should be of the form"

test/python/opflow/test_pauli_expectation.py

@@ -198,19 +198,13 @@ def test_grouped_pauli_expectation(self):
         )
         wf = CX @ (H ^ I) @ Zero
         expect_op = PauliExpectation(group_paulis=False).convert(~StateFn(two_qubit_H2) @ wf)
-        self.sampler._extract_circuitstatefns(expect_op)
+        self.sampler.convert(expect_op)
         num_circuits_ungrouped = len(self.sampler._circuit_ops_cache)
         self.assertEqual(num_circuits_ungrouped, 5)
 
         expect_op_grouped = PauliExpectation(group_paulis=True).convert(~StateFn(two_qubit_H2) @ wf)
-        q_instance = QuantumInstance(
-            BasicAer.get_backend("statevector_simulator"),
-            seed_simulator=self.seed,
-            seed_transpiler=self.seed,
-        )
-        sampler = CircuitSampler(q_instance)
-        sampler._extract_circuitstatefns(expect_op_grouped)
-        num_circuits_grouped = len(sampler._circuit_ops_cache)
+        self.sampler.convert(expect_op_grouped)
+        num_circuits_grouped = len(self.sampler._circuit_ops_cache)
         self.assertEqual(num_circuits_grouped, 2)
 
     @unittest.skip(reason="IBMQ testing not available in general.")