Qiskit · mergify · Apr 26, 2022 · Apr 1, 2022 · Apr 1, 2022 · Apr 1, 2022
@@ -138,6 +138,14 @@
    LinearFunctionsSynthesis
    LinearFunctionsToPermutations
 
+Post Layout (Post transpile qubit selection)
+============================================
+
+.. autosummary::
+   :toctree: ../stubs/
+
+   Vf2PostLayout
+
 Additional Passes
 =================
 
@@ -167,6 +175,7 @@
 from .layout import SabreLayout
 from .layout import CSPLayout
 from .layout import VF2Layout
+from .layout import VF2PostLayout
 from .layout import ApplyLayout
 from .layout import Layout2qDistance
 from .layout import EnlargeWithAncilla

@@ -19,6 +19,7 @@
 from .sabre_layout import SabreLayout
 from .csp_layout import CSPLayout
 from .vf2_layout import VF2Layout
+from .vf2_post_layout import VF2PostLayout
 from .apply_layout import ApplyLayout
 from .layout_2q_distance import Layout2qDistance
 from .enlarge_with_ancilla import EnlargeWithAncilla

@@ -0,0 +1,305 @@
+# 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.
+
+"""VF2PostLayout pass to find a layout after transpile using subgraph isomorphism"""
+from enum import Enum
+import logging
+import random
+import time
+from collections import defaultdict
+
+from retworkx import PyDiGraph, vf2_mapping
+
+from qiskit.transpiler.layout import Layout
+from qiskit.transpiler.basepasses import AnalysisPass
+from qiskit.transpiler.exceptions import TranspilerError
+from qiskit.providers.exceptions import BackendPropertyError
+
+
+logger = logging.getLogger(__name__)
+
+
+class VF2PostLayoutStopReason(Enum):
+    """Stop reasons for VF2PostLayout pass."""
+
+    SOLUTION_FOUND = "solution found"
+    NO_SOLUTION_FOUND = "nonexistent solution"
+    MORE_THAN_2Q = ">2q gates in basis"
+
+
+def _target_match(node_a, node_b):
+    if isinstance(node_a, set):
+        return node_a.issuperset(node_b.keys())
+    else:
+        return set(node_b).issubset(node_a)
+
+
+class VF2PostLayout(AnalysisPass):
+    """A pass for choosing a Layout after transpilation of a circuit onto a
+    Coupling graph, as a subgraph isomorphism problem, solved by VF2++.
+
+    Unlike the :class:`~.VF2PostLayout` transpiler pass which is designed to find an
+    initial layout for a circuit early in the transpilation pipeline this transpiler
+    pass is designed to try and find a better layout after transpilation is complete.
+    The initial layout phase of the transpiler doesn't have as much information available
+    as we do after transpilation. This pass is designed to be paired in a similar pipeline
+    as the layout passes. This pass will strip any idle wires from the circuit, use VF2
+    to find a subgraph in the coupling graph for the circuit to run on with better fidelity
+    and then update the circuit layout to use the new qubits.
+
+    If a solution is found that means there is a "perfect layout" and that no
+    further swap mapping or routing is needed. If a solution is found the layout
+    will be set in the property set as ``property_set['layout']``. However, if no
+    solution is found, no ``property_set['layout']`` is set. The stopping reason is
+    set in ``property_set['VF2PostLayout_stop_reason']`` in all the cases and will be
+    one of the values enumerated in ``VF2PostLayoutStopReason`` which has the
+    following values:
+
+        * ``"solution found"``: If a perfect layout was found.
+        * ``"nonexistent solution"``: If no perfect layout was found.
+        * ``">2q gates in basis"``: If VF2PostLayout can't work with basis
+
+    """
+
+    def __init__(
+        self,
+        target=None,
+        coupling_map=None,
+        properties=None,
+        seed=None,
+        call_limit=None,
+        time_limit=None,
+        max_trials=None,
+    ):
+        """Initialize a ``VF2PostLayout`` pass instance
+
+        Args:
+            target (Target): A target representing the backend device to run ``VF2PostLayout`` on.
+                If specified it will supersede a set value for ``properties`` and
+                ``coupling_map``.
+            coupling_map (CouplingMap): Directed graph representing a coupling map.
+            properties (BackendProperties): The backend properties for the backend. If
+                :meth:`~qiskit.providers.models.BackendProperties.readout_error` is available
+                it is used to score the layout.
+            seed (int): Sets the seed of the PRNG. -1 Means no node shuffling.
+            call_limit (int): The number of state visits to attempt in each execution of
+                VF2.
+            time_limit (float): The total time limit in seconds to run ``VF2PostLayout``
+            max_trials (int): The maximum number of trials to run VF2 to find
+                a layout. If this is not specified the number of trials will be limited
+                based on the number of edges in the interaction graph or the coupling graph
+                (whichever is larger). If set to a value <= 0 no limit on the number of trials
+                will be set.
+
+        Raises:
+            TypeError: At runtime, if neither ``coupling_map`` or ``target`` are provided.
+        """
+        super().__init__()
+        self.target = target
+        self.coupling_map = coupling_map
+        self.properties = properties
+        self.call_limit = call_limit
+        self.time_limit = time_limit
+        self.max_trials = max_trials
+        self.seed = seed
+
+    def run(self, dag):
+        """run the layout method"""
+        if self.target is None and (self.coupling_map is None or self.properties is None):
+            raise TranspilerError(
+                "A target must be specified or a coupling map and properties must be provided"
+            )
+        im_graph = PyDiGraph(multigraph=False)
+        im_graph_node_map = {}
+        reverse_im_graph_node_map = {}
+
+        for node in dag.op_nodes(include_directives=False):
+            len_args = len(node.qargs)
+            if len_args == 1:
+                if node.qargs[0] not in im_graph_node_map:
+                    weight = defaultdict(int)
+                    weight[node.name] += 1
+                    im_graph_node_map[node.qargs[0]] = im_graph.add_node(weight)
+                    reverse_im_graph_node_map[im_graph_node_map[node.qargs[0]]] = node.qargs[0]
+                else:
+                    im_graph[im_graph_node_map[node.qargs[0]]][node.op.name] += 1
+            if len_args == 2:
+                if node.qargs[0] not in im_graph_node_map:
+                    im_graph_node_map[node.qargs[0]] = im_graph.add_node(defaultdict(int))
+                    reverse_im_graph_node_map[im_graph_node_map[node.qargs[0]]] = node.qargs[0]
+                if node.qargs[1] not in im_graph_node_map:
+                    im_graph_node_map[node.qargs[1]] = im_graph.add_node(defaultdict(int))
+                    reverse_im_graph_node_map[im_graph_node_map[node.qargs[1]]] = node.qargs[1]
+                edge = (im_graph_node_map[node.qargs[0]], im_graph_node_map[node.qargs[1]])
+                if im_graph.has_edge(*edge):
+                    im_graph.get_edge_data(*edge)[node.name] += 1
+                else:
+                    weight = defaultdict(int)
+                    weight[node.name] += 1
+                    im_graph.add_edge(*edge, weight)
+            if len_args >= 3:
+                self.property_set[
+                    "VF2PostLayout_stop_reason"
+                ] = VF2PostLayoutStopReason.MORE_THAN_2Q
+                return
+
+        if self.target is not None:
+            cm_graph = PyDiGraph(multigraph=False)
+            cm_graph.add_nodes_from(
+                [self.target.operation_names_for_qargs((i,)) for i in range(self.target.num_qubits)]
+            )
+            for qargs in self.target.qargs:
+                len_args = len(qargs)
+                # If qargs == 1 we already populated it and if qargs > 2 there are no instructions
+                # using those in the circuit because we'd have already returned by this point
+                if len_args == 2:
+                    cm_graph.add_edge(
+                        qargs[0], qargs[1], self.target.operation_names_for_qargs(qargs)
+                    )
+            cm_nodes = list(cm_graph.node_indexes())
+        else:
+            cm_graph = self.coupling_map.graph
+            cm_nodes = list(cm_graph.node_indexes())
+            if self.seed != -1:
+                random.Random(self.seed).shuffle(cm_nodes)
+                shuffled_cm_graph = type(cm_graph)()
+                shuffled_cm_graph.add_nodes_from(cm_nodes)
+                new_edges = [
+                    (cm_nodes[edge[0]], cm_nodes[edge[1]]) for edge in cm_graph.edge_list()
+                ]
+                shuffled_cm_graph.add_edges_from_no_data(new_edges)
+                cm_nodes = [k for k, v in sorted(enumerate(cm_nodes), key=lambda item: item[1])]
+                cm_graph = shuffled_cm_graph
+
+        # To avoid trying to over optimize the result by default limit the number
+        # of trials based on the size of the graphs. For circuits with simple layouts
+        # like an all 1q circuit we don't want to sit forever trying every possible
+        # mapping in the search space
+        if self.max_trials is None:
+            im_graph_edge_count = len(im_graph.edge_list())
+            cm_graph_edge_count = len(cm_graph.edge_list())
+            self.max_trials = max(im_graph_edge_count, cm_graph_edge_count) + 15
+
+        logger.debug("Running VF2 to find post transpile mappings")
+        if self.target:
+            mappings = vf2_mapping(
+                cm_graph,
+                im_graph,
+                node_matcher=_target_match,
+                edge_matcher=_target_match,
+                subgraph=True,
+                id_order=False,
+                induced=False,
+                call_limit=self.call_limit,
+            )
+        else:
+            mappings = vf2_mapping(
+                cm_graph,
+                im_graph,
+                subgraph=True,
+                id_order=False,
+                induced=False,
+                call_limit=self.call_limit,
+            )
+        chosen_layout = None
+        initial_layout = Layout(dict(enumerate(dag.qubits)))
+        chosen_layout_score = self._score_layout(
+            initial_layout, im_graph_node_map, reverse_im_graph_node_map, im_graph
+        )
+        logger.debug("Initial layout has score %s", chosen_layout_score)
+
+        start_time = time.time()
+        trials = 0
+        for mapping in mappings:
+            trials += 1
+            logger.debug("Running trial: %s", trials)
+            stop_reason = VF2PostLayoutStopReason.SOLUTION_FOUND
+            layout = Layout(
+                {reverse_im_graph_node_map[im_i]: cm_nodes[cm_i] for cm_i, im_i in mapping.items()}
+            )
+            layout_score = self._score_layout(
+                layout, im_graph_node_map, reverse_im_graph_node_map, im_graph
+            )
+            logger.debug("Trial %s has score %s", trials, layout_score)
+            if layout_score < chosen_layout_score:
+                logger.debug(
+                    "Found layout %s has a lower score (%s) than previous best %s (%s)",
+                    layout,
+                    layout_score,
+                    chosen_layout,
+                    chosen_layout_score,
+                )
+                chosen_layout = layout
+                chosen_layout_score = layout_score
+            if self.max_trials > 0 and trials >= self.max_trials:
+                logger.debug("Trial %s is >= configured max trials %s", trials, self.max_trials)
+                break
+            elapsed_time = time.time() - start_time
+            if self.time_limit is not None and elapsed_time >= self.time_limit:
+                logger.debug(
+                    "VFPostLayout has taken %s which exceeds configured max time: %s",
+                    elapsed_time,
+                    self.time_limit,
+                )
+                break
+        if chosen_layout is None:
+            stop_reason = VF2PostLayoutStopReason.NO_SOLUTION_FOUND
+        else:
+            self.property_set["layout"] = chosen_layout
+            for reg in dag.qregs.values():
+                self.property_set["layout"].add_register(reg)
+
+        self.property_set["VF2PostLayout_stop_reason"] = stop_reason
+
+    def _score_layout(self, layout, bit_map, reverse_bit_map, im_graph):
+        bits = layout.get_virtual_bits()
+        score = 0
+        if self.target is not None:
+            for bit, node_index in bit_map.items():
+                gate_counts = im_graph[node_index]
+                for gate, count in gate_counts.items():
+                    if self.target[gate] is not None and None not in self.target[gate]:
+                        props = self.target[gate][(bits[bit],)]
+                        if props is not None and props.error is not None:
+                            score += props.error * count
+
+            for edge in im_graph.edge_index_map().values():
+                qargs = (bits[reverse_bit_map[edge[0]]], bits[reverse_bit_map[edge[1]]])
+                gate_counts = edge[2]
+                for gate, count in gate_counts.items():
+                    if self.target[gate] is not None and None not in self.target[gate]:
+                        props = self.target[gate][qargs]
+                        if props is not None and props.error is not None:
+                            score += props.error * count
+        else:
+            for bit, node_index in bit_map.items():
+                gate_counts = im_graph[node_index]
+                for gate, count in gate_counts.items():
+                    if gate == "measure":
+                        try:
+                            score += self.properties.readout_error(bits[bit]) * count
+                        except BackendPropertyError:
+                            pass
+                    else:
+                        try:
+                            score += self.properties.gate_error(gate, bits[bit]) * count
+                        except BackendPropertyError:
+                            pass
+            for edge in im_graph.edge_index_map().values():
+                qargs = (bits[reverse_bit_map[edge[0]]], bits[reverse_bit_map[edge[1]]])
+                gate_counts = edge[2]
+                for gate, count in gate_counts.items():
+                    try:
+                        score += self.properties.gate_error(gate, qargs) * count
+                    except BackendPropertyError:
+                        pass
+        return score
@@ -28,6 +28,7 @@
 from qiskit.transpiler.passes import GateDirection
 from qiskit.transpiler.passes import SetLayout
 from qiskit.transpiler.passes import VF2Layout
+from qiskit.transpiler.passes import VF2PostLayout
 from qiskit.transpiler.passes import TrivialLayout
 from qiskit.transpiler.passes import DenseLayout
 from qiskit.transpiler.passes import NoiseAdaptiveLayout
@@ -61,6 +62,7 @@
 from qiskit.transpiler.passes import Error
 from qiskit.transpiler.passes import ContainsInstruction
 from qiskit.transpiler.passes.layout.vf2_layout import VF2LayoutStopReason
+from qiskit.transpiler.passes.layout.vf2_post_layout import VF2PostLayoutStopReason
 
 from qiskit.transpiler import TranspilerError
 
@@ -368,4 +370,29 @@ def _require_alignment(property_set):
         # Call padding pass if circuit is scheduled
         pm1.append(PadDelay())
 
+    if target is not None or (coupling_map and backend_properties):
+
+        def _post_layout_condition(property_set):
+            # if VF2 layout stopped for any reason other than solution found we need
+            # to run layout since VF2 didn't converge.
+            if (
+                property_set["VF2PostLayout_stop_reason"] is not None
+                and property_set["VF2PostLayout_stop_reason"]
+                is VF2PostLayoutStopReason.SOLUTION_FOUND
+            ):
+                return True
+            return False
+
+        pm1.append(
+            VF2PostLayout(
+                target,
+                coupling_map,
+                backend_properties,
+                seed_transpiler,
+                call_limit=int(5e4),  # Set call limit to ~100ms with retworkx 0.10.2
+                time_limit=0.1,
+            )
+        )
+        pm1.append(ApplyLayout(), condition=_post_layout_condition)
+
     return pm1