10294768045

Committed 08 Aug 2024 02:13AM UTC coverage: 89.958%. First build

Build # 10294768045

Build Type

Pull #12923

github

Committed by

mergify[bot]

Commit Message

Fix dag visualization with Var wires (#12848)

* Fix dag visualization with Var wires

This commit fixes the dag visualization for DAGs with classical
variables. The Var type was not handled in the attribute callback
functions for nodes and edges. This was causing the visualizer to fail
if the dag contained these types. This fixes this by adding explict
handling for the Var types and using the name attribute of the Var
object.

* Add release note and test

(cherry picked from commit adbe88707)

Pull Request Pull Request #12923: Fix dag visualization with Var wires (backport #12848)

Run Details

0 of 6 new or added lines in 1 file covered. (0.0%)

61863 of 68769 relevant lines covered (89.96%)

235299.13 hits per line

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

9.65

/qiskit/visualization/dag_visualization.py

# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018, 2020.
#
# 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.

# pylint: disable=invalid-name

"""
Visualization function for DAG circuit representation.
"""
from rustworkx.visualization import graphviz_draw

from qiskit.dagcircuit.dagnode import DAGOpNode, DAGInNode, DAGOutNode
from qiskit.circuit import Qubit, Clbit, ClassicalRegister
from qiskit.circuit.classical import expr
from qiskit.converters import dagdependency_to_circuit
from qiskit.utils import optionals as _optionals
from qiskit.exceptions import InvalidFileError
from .exceptions import VisualizationError


@_optionals.HAS_GRAPHVIZ.require_in_call
def dag_drawer(dag, scale=0.7, filename=None, style="color"):
    """Plot the directed acyclic graph (dag) to represent operation dependencies
    in a quantum circuit.

    This function calls the :func:`~rustworkx.visualization.graphviz_draw` function from the
    ``rustworkx`` package to draw the DAG.

    Args:
        dag (DAGCircuit): The dag to draw.
        scale (float): scaling factor
        filename (str): file path to save image to (format inferred from name)
        style (str): 'plain': B&W graph
                     'color' (default): color input/output/op nodes

    Returns:
        PIL.Image: if in Jupyter notebook and not saving to file,
            otherwise None.

    Raises:
        VisualizationError: when style is not recognized.
        InvalidFileError: when filename provided is not valid

    Example:
        .. plot::
           :include-source:

            from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
            from qiskit.dagcircuit import DAGCircuit
            from qiskit.converters import circuit_to_dag
            from qiskit.visualization import dag_drawer

            q = QuantumRegister(3, 'q')
            c = ClassicalRegister(3, 'c')
            circ = QuantumCircuit(q, c)
            circ.h(q[0])
            circ.cx(q[0], q[1])
            circ.measure(q[0], c[0])
            circ.rz(0.5, q[1]).c_if(c, 2)

            dag = circuit_to_dag(circ)
            dag_drawer(dag)
    """

    # NOTE: use type str checking to avoid potential cyclical import
    # the two tradeoffs ere that it will not handle subclasses and it is
    # slower (which doesn't matter for a visualization function)
    type_str = str(type(dag))
    register_bit_labels = {
        bit: f"{reg.name}[{idx}]"
        for reg in list(dag.qregs.values()) + list(dag.cregs.values())
        for (idx, bit) in enumerate(reg)
    }
    if "DAGDependency" in type_str:
        # pylint: disable=cyclic-import
        from qiskit.visualization.circuit._utils import get_bit_reg_index

        qubit_indices = {bit: index for index, bit in enumerate(dag.qubits)}
        clbit_indices = {bit: index for index, bit in enumerate(dag.clbits)}
        graph_attrs = {"dpi": str(100 * scale)}
        dag_dep_circ = dagdependency_to_circuit(dag)

        def node_attr_func(node):
            if "DAGDependencyV2" in type_str:
                nid_str = str(node._node_id)
            else:
                nid_str = str(node.node_id)
            if style == "plain":
                return {}
            if style == "color":
                n = {}
                args = []
                for count, arg in enumerate(node.qargs + node.cargs):
                    if count > 4:
                        args.append("...")
                        break
                    if isinstance(arg, Qubit):
                        f_str = f"q_{qubit_indices[arg]}"
                    elif isinstance(arg, Clbit):
                        f_str = f"c_{clbit_indices[arg]}"
                    else:
                        f_str = f"{arg.index}"
                    arg_str = register_bit_labels.get(arg, f_str)
                    args.append(arg_str)

                n["color"] = "black"
                n["label"] = (
                    nid_str + ": " + str(node.name) + " (" + str(args)[1:-1].replace("'", "") + ")"
                )
                if node.name == "barrier":
                    n["style"] = "filled"
                    n["fillcolor"] = "grey"
                elif getattr(node.op, "_directive", False):
                    n["style"] = "filled"
                    n["fillcolor"] = "red"
                elif getattr(node.op, "condition", None):
                    condition = node.op.condition
                    if isinstance(condition, expr.Expr):
                        cond_txt = " (cond: [Expr]) ("
                    elif isinstance(condition[0], ClassicalRegister):
                        cond_txt = f" (cond: {condition[0].name}, {int(condition[1])}) ("
                    else:
                        register, bit_index, reg_index = get_bit_reg_index(
                            dag_dep_circ, condition[0]
                        )
                        if register is not None:
                            cond_txt = (
                                f" (cond: {register.name}[{reg_index}], {int(condition[1])}) ("
                            )
                        else:
                            cond_txt = f" (cond: {bit_index}, {int(condition[1])}) ("
                    n["style"] = "filled"
                    n["fillcolor"] = "green"
                    n["label"] = (
                        nid_str
                        + ": "
                        + str(node.name)
                        + cond_txt
                        + str(args)[1:-1].replace("'", "")
                        + ")"
                    )
                elif node.name != "measure":  # measure is unfilled
                    n["style"] = "filled"
                    n["fillcolor"] = "lightblue"
                return n
            else:
                raise VisualizationError("Unrecognized style %s for the dag_drawer." % style)

        edge_attr_func = None

    else:
        graph_attrs = {"dpi": str(100 * scale)}

        def node_attr_func(node):
            if style == "plain":
                return {}
            if style == "color":
                n = {}
                if isinstance(node, DAGOpNode):
                    n["label"] = node.name
                    n["color"] = "blue"
                    n["style"] = "filled"
                    n["fillcolor"] = "lightblue"
                if isinstance(node, DAGInNode):
                    if isinstance(node.wire, Qubit):
                        label = register_bit_labels.get(
                            node.wire, f"q_{dag.find_bit(node.wire).index}"
                        )
                    elif isinstance(node.wire, Clbit):
                        label = register_bit_labels.get(
                            node.wire, f"c_{dag.find_bit(node.wire).index}"
                        )
                    else:
                        label = str(node.wire.name)

                    n["label"] = label
                    n["color"] = "black"
                    n["style"] = "filled"
                    n["fillcolor"] = "green"
                if isinstance(node, DAGOutNode):
                    if isinstance(node.wire, Qubit):
                        label = register_bit_labels.get(
                            node.wire, f"q[{dag.find_bit(node.wire).index}]"
                        )
                    elif isinstance(node.wire, Clbit):
                        label = register_bit_labels.get(
                            node.wire, f"c[{dag.find_bit(node.wire).index}]"
                        )
                    else:
                        label = str(node.wire.name)
                    n["label"] = label
                    n["color"] = "black"
                    n["style"] = "filled"
                    n["fillcolor"] = "red"
                return n
            else:
                raise VisualizationError("Invalid style %s" % style)

        def edge_attr_func(edge):
            e = {}
            if isinstance(edge, Qubit):
                label = register_bit_labels.get(edge, f"q_{dag.find_bit(edge).index}")
            elif isinstance(edge, Clbit):
                label = register_bit_labels.get(edge, f"c_{dag.find_bit(edge).index}")
            else:
                label = str(edge.name)
            e["label"] = label
            return e

    image_type = None
    if filename:
        if "." not in filename:
            raise InvalidFileError("Parameter 'filename' must be in format 'name.extension'")
        image_type = filename.split(".")[-1]
    return graphviz_draw(
        dag._multi_graph,
        node_attr_func,
        edge_attr_func,
        graph_attrs,
        filename,
        image_type,
    )

1	# This code is part of Qiskit.
2	#
3	# (C) Copyright IBM 2017, 2018, 2020.
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	# pylint: disable=invalid-name
14
15	"""	1✔
16	Visualization function for DAG circuit representation.
17	"""
18	from rustworkx.visualization import graphviz_draw	1✔
19
20	from qiskit.dagcircuit.dagnode import DAGOpNode, DAGInNode, DAGOutNode	1✔
21	from qiskit.circuit import Qubit, Clbit, ClassicalRegister	1✔
22	from qiskit.circuit.classical import expr	1✔
23	from qiskit.converters import dagdependency_to_circuit	1✔
24	from qiskit.utils import optionals as _optionals	1✔
25	from qiskit.exceptions import InvalidFileError	1✔
26	from .exceptions import VisualizationError	1✔
27
28
29	@_optionals.HAS_GRAPHVIZ.require_in_call	1✔
30	def dag_drawer(dag, scale=0.7, filename=None, style="color"):	1✔
31	"""Plot the directed acyclic graph (dag) to represent operation dependencies
32	in a quantum circuit.
33
34	This function calls the :func:`~rustworkx.visualization.graphviz_draw` function from the
35	``rustworkx`` package to draw the DAG.
36
37	Args:
38	dag (DAGCircuit): The dag to draw.
39	scale (float): scaling factor
40	filename (str): file path to save image to (format inferred from name)
41	style (str): 'plain': B&W graph
42	'color' (default): color input/output/op nodes
43
44	Returns:
45	PIL.Image: if in Jupyter notebook and not saving to file,
46	otherwise None.
47
48	Raises:
49	VisualizationError: when style is not recognized.
50	InvalidFileError: when filename provided is not valid
51
52	Example:
53	.. plot::
54	:include-source:
55
56	from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
57	from qiskit.dagcircuit import DAGCircuit
58	from qiskit.converters import circuit_to_dag
59	from qiskit.visualization import dag_drawer
60
61	q = QuantumRegister(3, 'q')
62	c = ClassicalRegister(3, 'c')
63	circ = QuantumCircuit(q, c)
64	circ.h(q[0])
65	circ.cx(q[0], q[1])
66	circ.measure(q[0], c[0])
67	circ.rz(0.5, q[1]).c_if(c, 2)
68
69	dag = circuit_to_dag(circ)
70	dag_drawer(dag)
71	"""
72
73	# NOTE: use type str checking to avoid potential cyclical import
74	# the two tradeoffs ere that it will not handle subclasses and it is
75	# slower (which doesn't matter for a visualization function)
76	type_str = str(type(dag))	×
77	register_bit_labels = {	×
78	bit: f"{reg.name}[{idx}]"
79	for reg in list(dag.qregs.values()) + list(dag.cregs.values())
80	for (idx, bit) in enumerate(reg)
81	}
82	if "DAGDependency" in type_str:	×
83	# pylint: disable=cyclic-import
84	from qiskit.visualization.circuit._utils import get_bit_reg_index	×
85
86	qubit_indices = {bit: index for index, bit in enumerate(dag.qubits)}	×
87	clbit_indices = {bit: index for index, bit in enumerate(dag.clbits)}	×
88	graph_attrs = {"dpi": str(100 * scale)}	×
89	dag_dep_circ = dagdependency_to_circuit(dag)	×
90
91	def node_attr_func(node):	×
92	if "DAGDependencyV2" in type_str:	×
93	nid_str = str(node._node_id)	×
94	else:
95	nid_str = str(node.node_id)	×
96	if style == "plain":	×
97	return {}	×
98	if style == "color":	×
99	n = {}	×
100	args = []	×
101	for count, arg in enumerate(node.qargs + node.cargs):	×
102	if count > 4:	×
103	args.append("...")	×
104	break	×
105	if isinstance(arg, Qubit):	×
106	f_str = f"q_{qubit_indices[arg]}"	×
107	elif isinstance(arg, Clbit):	×
108	f_str = f"c_{clbit_indices[arg]}"	×
109	else:
110	f_str = f"{arg.index}"	×
111	arg_str = register_bit_labels.get(arg, f_str)	×
112	args.append(arg_str)	×
113
114	n["color"] = "black"	×
115	n["label"] = (	×
116	nid_str + ": " + str(node.name) + " (" + str(args)[1:-1].replace("'", "") + ")"
117	)
118	if node.name == "barrier":	×
119	n["style"] = "filled"	×
120	n["fillcolor"] = "grey"	×
121	elif getattr(node.op, "_directive", False):	×
122	n["style"] = "filled"	×
123	n["fillcolor"] = "red"	×
124	elif getattr(node.op, "condition", None):	×
125	condition = node.op.condition	×
126	if isinstance(condition, expr.Expr):	×
127	cond_txt = " (cond: [Expr]) ("	×
128	elif isinstance(condition[0], ClassicalRegister):	×
129	cond_txt = f" (cond: {condition[0].name}, {int(condition[1])}) ("	×
130	else:
131	register, bit_index, reg_index = get_bit_reg_index(	×
132	dag_dep_circ, condition[0]
133	)
134	if register is not None:	×
135	cond_txt = (	×
136	f" (cond: {register.name}[{reg_index}], {int(condition[1])}) ("
137	)
138	else:
139	cond_txt = f" (cond: {bit_index}, {int(condition[1])}) ("	×
140	n["style"] = "filled"	×
141	n["fillcolor"] = "green"	×
142	n["label"] = (	×
143	nid_str
144	+ ": "
145	+ str(node.name)
146	+ cond_txt
147	+ str(args)[1:-1].replace("'", "")
148	+ ")"
149	)
150	elif node.name != "measure": # measure is unfilled	×
151	n["style"] = "filled"	×
152	n["fillcolor"] = "lightblue"	×
153	return n	×
154	else:
155	raise VisualizationError("Unrecognized style %s for the dag_drawer." % style)	×
156
157	edge_attr_func = None	×
158
159	else:
160	graph_attrs = {"dpi": str(100 * scale)}	×
161
162	def node_attr_func(node):	×
163	if style == "plain":	×
164	return {}	×
165	if style == "color":	×
166	n = {}	×
167	if isinstance(node, DAGOpNode):	×
168	n["label"] = node.name	×
169	n["color"] = "blue"	×
170	n["style"] = "filled"	×
171	n["fillcolor"] = "lightblue"	×
172	if isinstance(node, DAGInNode):	×
173	if isinstance(node.wire, Qubit):	×
174	label = register_bit_labels.get(	×
175	node.wire, f"q_{dag.find_bit(node.wire).index}"
176	)
NEW 177	elif isinstance(node.wire, Clbit):	×
178	label = register_bit_labels.get(	×
179	node.wire, f"c_{dag.find_bit(node.wire).index}"
180	)
181	else:
NEW 182	label = str(node.wire.name)	×
183
184	n["label"] = label	×
185	n["color"] = "black"	×
186	n["style"] = "filled"	×
187	n["fillcolor"] = "green"	×
188	if isinstance(node, DAGOutNode):	×
189	if isinstance(node.wire, Qubit):	×
190	label = register_bit_labels.get(	×
191	node.wire, f"q[{dag.find_bit(node.wire).index}]"
192	)
NEW 193	elif isinstance(node.wire, Clbit):	×
194	label = register_bit_labels.get(	×
195	node.wire, f"c[{dag.find_bit(node.wire).index}]"
196	)
197	else:
NEW 198	label = str(node.wire.name)	×
199	n["label"] = label	×
200	n["color"] = "black"	×
201	n["style"] = "filled"	×
202	n["fillcolor"] = "red"	×
203	return n	×
204	else:
205	raise VisualizationError("Invalid style %s" % style)	×
206
207	def edge_attr_func(edge):	×
208	e = {}	×
209	if isinstance(edge, Qubit):	×
210	label = register_bit_labels.get(edge, f"q_{dag.find_bit(edge).index}")	×
NEW 211	elif isinstance(edge, Clbit):	×
212	label = register_bit_labels.get(edge, f"c_{dag.find_bit(edge).index}")	×
213	else:
NEW 214	label = str(edge.name)	×
215	e["label"] = label	×
216	return e	×
217
218	image_type = None	×
219	if filename:	×
220	if "." not in filename:	×
221	raise InvalidFileError("Parameter 'filename' must be in format 'name.extension'")	×
222	image_type = filename.split(".")[-1]	×
223	return graphviz_draw(	×
224	dag._multi_graph,
225	node_attr_func,
226	edge_attr_func,
227	graph_attrs,
228	filename,
229	image_type,
230	)

Qiskit / qiskit / 10294768045

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