{
"cells": [
{
"cell_type": "markdown",
"id": "4cb32582",
"metadata": {},
"source": [
"---\n",
"title: \"Travailler avec les DAG dans les passes du transpilateur\"\n",
"description: \"Comment utiliser les graphes acycliques dirigés (DAG) pour analyser et transformer les circuits quantiques dans les passes du transcompilateur Qiskit\"\n",
"---\n",
"\n",
"{/* cspell:ignore subdag DAGOpNode qargs cargs dag_drawer couplinglist */}\n",
"\n",
"\n",
"\n",
"# Travailler avec les DAG dans les passes du transpilateur\n",
"\n",
"Dans Qiskit, lors des étapes de transpilation, les circuits sont représentés à l'aide d'un DAG. En général, un DAG est composé de sommets (également appelés \"nœuds\") et d'arêtes dirigées qui relient des paires de sommets dans une orientation particulière. Cette représentation est stockée à l'aide d'objets `qiskit.dagcircuit.DAGCircuit` composés d'objets individuels `DagNode` . L'avantage de cette représentation par rapport à une simple liste de portes (c'est-à-dire une liste de réseaux) est que le flux d'informations entre les opérations est explicite, ce qui facilite la prise de décisions en matière de transformation.\n",
"\n",
"Ce guide montre comment travailler avec les DAG et les utiliser pour écrire des passes de transpilation personnalisées. Il commencera par la construction d'un circuit simple et l'examen de sa représentation DAG, puis explorera les opérations DAG de base et mettra en œuvre une passe `BasicMapper` personnalisée.\n",
"\n",
"\n",
"\n",
"## Construisez un circuit et examinez son DAG\n",
"\n",
"L'extrait de code ci-dessous illustre le DAG en créant un circuit simple qui prépare un état Bell et applique une rotation $R_Z$, en fonction du résultat de la mesure.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "version-info-cell",
"metadata": {
"tags": [
"version-info"
]
},
"source": [
"{/*\n",
" DO NOT EDIT THIS CELL!!!\n",
" This cell's content is generated automatically by a script. Anything you add\n",
" here will be removed next time the notebook is run. To add new content, create\n",
" a new cell before or after this one.\n",
" */}\n",
"\n",
"\n",
" \n",
" Le code de cette page a été développé en tenant compte des exigences suivantes.\n",
" Nous recommandons d'utiliser ces versions ou des versions plus récentes.\n",
"\n",
" ```\n",
" qiskit[all]~=2.5.1\n",
" ```\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "1d16892a",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 1,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit\n",
"from qiskit.converters import circuit_to_dag\n",
"from qiskit.visualization import circuit_drawer\n",
"from qiskit.visualization.dag_visualization import dag_drawer\n",
"\n",
"# Create circuit\n",
"q = QuantumRegister(3, \"q\")\n",
"c = ClassicalRegister(3, \"c\")\n",
"circ = QuantumCircuit(q, c)\n",
"circ.h(q[0])\n",
"circ.cx(q[0], q[1])\n",
"circ.measure(q[0], c[0])\n",
"\n",
"# Qiskit 2.0 uses if_test instead of c_if\n",
"with circ.if_test((c, 2)):\n",
" circ.rz(0.5, q[1])\n",
"\n",
"circuit_drawer(circ, output=\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "5971b6ed",
"metadata": {},
"source": [
"Dans le DAG, il y a trois types de nœuds : les nœuds d'entrée qubit/clbit (vert), les nœuds d'opération (bleu) et les nœuds de sortie (rouge). Chaque arête indique le flux de données (ou la dépendance) entre deux nœuds. Utilisez la fonction qiskit.tools.visualization.dag\\_drawer () pour visualiser le DAG de ce circuit. (Installez la [bibliothèque Graphviz](https://graphviz.org/download/) pour exécuter cette opération)\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "e498faa3",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Convert to DAG\n",
"dag = circuit_to_dag(circ)\n",
"dag_drawer(dag)"
]
},
{
"cell_type": "markdown",
"id": "3b728136",
"metadata": {},
"source": [
"\n",
"\n",
"## Opérations DAG de base\n",
"\n",
"Les exemples de code ci-dessous illustrent des opérations courantes avec les DAG, notamment l'accès aux nœuds, l'ajout d'opérations et la substitution de sous-circuits. Ces opérations constituent la base de l'élaboration des passes de transpondeur.\n",
"\n",
"\n",
"\n",
"## Obtenir tous les nœuds d'opération dans le DAG\n",
"\n",
"La méthode `op_nodes()` renvoie une liste itérable d'objets `DAGOpNode` dans le circuit :\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "4f848695",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[DAGOpNode(op=Instruction(name='h', num_qubits=1, num_clbits=0, params=[]), qargs=(,), cargs=()),\n",
" DAGOpNode(op=Instruction(name='cx', num_qubits=2, num_clbits=0, params=[]), qargs=(, ), cargs=()),\n",
" DAGOpNode(op=Instruction(name='measure', num_qubits=1, num_clbits=1, params=[]), qargs=(,), cargs=(,)),\n",
" DAGOpNode(op=Instruction(name='if_else', num_qubits=1, num_clbits=3, params=[, None]), qargs=(,), cargs=(, , ))]"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"dag.op_nodes()"
]
},
{
"cell_type": "markdown",
"id": "8f2676b9",
"metadata": {},
"source": [
"Chaque nœud est une instance de la classe `DAGOpNode` :\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "5866159f",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"node name: if_else\n",
"op: Instruction(name='if_else', num_qubits=1, num_clbits=3, params=[, None])\n",
"qargs: (,)\n",
"cargs: (, , )\n",
"condition: (ClassicalRegister(3, 'c'), 2)\n"
]
}
],
"source": [
"node = dag.op_nodes()[3]\n",
"print(\"node name:\", node.name)\n",
"print(\"op:\", node.op)\n",
"print(\"qargs:\", node.qargs)\n",
"print(\"cargs:\", node.cargs)\n",
"print(\"condition:\", node.op.condition)"
]
},
{
"cell_type": "markdown",
"id": "f2560cc1",
"metadata": {},
"source": [
"\n",
"\n",
"## Ajouter une opération à l'arrière\n",
"\n",
"Une opération est ajoutée à la fin du circuit DAGCircuit à l'aide de la méthode `apply_operation_back()` . Cette opération ajoute la porte spécifiée pour agir sur les qubits donnés après toutes les opérations existantes dans le circuit.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "3c144b49",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit.circuit.library import HGate\n",
"\n",
"dag.apply_operation_back(HGate(), qargs=[q[0]])\n",
"dag_drawer(dag)"
]
},
{
"cell_type": "markdown",
"id": "80af1d3d",
"metadata": {},
"source": [
"\n",
"\n",
"## Ajouter une opération à l'avant\n",
"\n",
"Une opération est ajoutée au début du circuit DAGC à l'aide de la méthode `apply_operation_front()` . Cette opération insère la porte spécifiée avant toutes les opérations existantes dans le circuit, ce qui en fait la première opération exécutée.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "ed80a69f",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit.circuit.library import CCXGate\n",
"\n",
"dag.apply_operation_front(CCXGate(), qargs=[q[0], q[1], q[2]])\n",
"dag_drawer(dag)"
]
},
{
"cell_type": "markdown",
"id": "4bcdf5fe",
"metadata": {},
"source": [
"\n",
"\n",
"## Remplacer un nœud par un sous-circuit\n",
"\n",
"Un nœud représentant une opération spécifique dans le DAGCircuit est remplacé par un sous-circuit. Tout d'abord, un nouveau sous-DAG est construit avec la séquence de portes souhaitée, puis le nœud cible est remplacé par ce sous-DAG à l'aide de `substitute_node_with_dag()`, en préservant les connexions avec le reste du circuit.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "fdb3dd70",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit.dagcircuit import DAGCircuit\n",
"from qiskit.circuit.library import CHGate, U2Gate, CXGate\n",
"\n",
"# Build sub-DAG\n",
"mini_dag = DAGCircuit()\n",
"p = QuantumRegister(2, \"p\")\n",
"mini_dag.add_qreg(p)\n",
"mini_dag.apply_operation_back(CHGate(), qargs=[p[1], p[0]])\n",
"mini_dag.apply_operation_back(U2Gate(0.1, 0.2), qargs=[p[1]])\n",
"\n",
"# Replace CX with mini_dag\n",
"cx_node = dag.op_nodes(op=CXGate).pop()\n",
"dag.substitute_node_with_dag(cx_node, mini_dag, wires=[p[0], p[1]])\n",
"dag_drawer(dag)"
]
},
{
"cell_type": "markdown",
"id": "028566f7",
"metadata": {},
"source": [
"Une fois toutes les transformations terminées, le DAG peut être reconverti en un objet ordinaire `QuantumCircuit` . C'est ainsi que fonctionne le pipeline de transposition. Un circuit est pris, traité sous forme de DAG, et un circuit transformé est produit en sortie.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "786571f7",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit.converters import dag_to_circuit\n",
"\n",
"new_circ = dag_to_circuit(dag)\n",
"circuit_drawer(new_circ, output=\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "f743bb3b",
"metadata": {},
"source": [
"\n",
"\n",
"## Mettre en œuvre une passe d' BasicMapper\n",
"\n",
"La structure DAG peut être exploitée pour l'écriture de passes de transposition. Dans l'exemple ci-dessous, une passe `BasicMapper` est mise en œuvre pour faire correspondre un circuit arbitraire à un dispositif dont la connectivité des qubits est restreinte. Pour plus d'informations, consultez le guide sur l' [écriture de passes de transpilation personnalisées](/docs/guides/custom-transpiler-pass).\n",
"\n",
"La passe est définie comme une `TransformationPass`, ce qui signifie qu'elle modifie le circuit. Pour ce faire, il parcourt le DAG couche par couche, en vérifiant si chaque instruction satisfait aux contraintes imposées par la carte de couplage de l'appareil. Si une violation est détectée, un chemin de permutation est déterminé et les portes SWAP nécessaires sont insérées en conséquence.\n",
"\n",
"Lors de la création d'une passe de transpondeur, la première décision consiste à choisir si la passe doit hériter de `TransformationPass` ou de `AnalysisPass`. Les passes de transformation sont conçues pour modifier le circuit, tandis que les passes d'analyse ne visent qu'à extraire des informations qui seront utilisées par les passes suivantes. La fonctionnalité principale est ensuite mise en œuvre dans la méthode `run(dag)` . Enfin, le laissez-passer doit être enregistré dans le module `qiskit.transpiler.passes` .\n",
"\n",
"Dans cette passe spécifique, le DAG est parcouru couche par couche (où chaque couche contient des opérations qui agissent sur des ensembles disjoints de qubits et peuvent donc être exécutées indépendamment). Pour chaque opération, si les contraintes de la carte de couplage ne sont pas respectées, un chemin de permutation approprié est identifié et les permutations nécessaires sont insérées pour mettre les qubits concernés en contiguïté.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "8c0d7e5a",
"metadata": {},
"outputs": [],
"source": [
"from qiskit.transpiler.basepasses import TransformationPass\n",
"from qiskit.transpiler import Layout\n",
"from qiskit.circuit.library import SwapGate\n",
"\n",
"\n",
"class BasicSwap(TransformationPass):\n",
" def __init__(self, coupling_map, initial_layout=None):\n",
" super().__init__()\n",
" self.coupling_map = coupling_map\n",
" self.initial_layout = initial_layout\n",
"\n",
" def run(self, dag):\n",
" new_dag = DAGCircuit()\n",
" for qreg in dag.qregs.values():\n",
" new_dag.add_qreg(qreg)\n",
" for creg in dag.cregs.values():\n",
" new_dag.add_creg(creg)\n",
"\n",
" if self.initial_layout is None:\n",
" self.initial_layout = Layout.generate_trivial_layout(\n",
" *dag.qregs.values()\n",
" )\n",
"\n",
" current_layout = self.initial_layout.copy()\n",
"\n",
" for layer in dag.serial_layers():\n",
" subdag = layer[\"graph\"]\n",
" for gate in subdag.two_qubit_ops():\n",
" q0, q1 = gate.qargs\n",
" p0 = current_layout[q0]\n",
" p1 = current_layout[q1]\n",
"\n",
" if self.coupling_map.distance(p0, p1) != 1:\n",
" path = self.coupling_map.shortest_undirected_path(p0, p1)\n",
" for i in range(len(path) - 2):\n",
" wire1, wire2 = path[i], path[i + 1]\n",
" qubit1 = current_layout[wire1]\n",
" qubit2 = current_layout[wire2]\n",
" new_dag.apply_operation_back(\n",
" SwapGate(), qargs=[qubit1, qubit2]\n",
" )\n",
" current_layout.swap(wire1, wire2)\n",
"\n",
" new_dag.compose(\n",
" subdag, qubits=current_layout.reorder_bits(new_dag.qubits)\n",
" )\n",
"\n",
" return new_dag"
]
},
{
"cell_type": "markdown",
"id": "4a95eaab",
"metadata": {},
"source": [
"La passe peut maintenant être testée sur un petit circuit d'exemple. Un gestionnaire de laissez-passer est construit avec le laissez-passer nouvellement défini. Le circuit de l'exemple est alors fourni à ce gestionnaire de passage et un nouveau circuit transformé est obtenu en sortie.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "2f35375f",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit.transpiler import CouplingMap, PassManager\n",
"from qiskit import QuantumRegister, QuantumCircuit\n",
"\n",
"q = QuantumRegister(7, \"q\")\n",
"in_circ = QuantumCircuit(q)\n",
"in_circ.h(q[0])\n",
"in_circ.cx(q[0], q[4])\n",
"in_circ.cx(q[2], q[3])\n",
"in_circ.cx(q[6], q[1])\n",
"in_circ.cx(q[5], q[0])\n",
"in_circ.rz(0.1, q[2])\n",
"in_circ.cx(q[5], q[0])\n",
"\n",
"coupling = [[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6]]\n",
"coupling_map = CouplingMap(couplinglist=coupling)\n",
"\n",
"pm = PassManager()\n",
"pm.append(BasicSwap(coupling_map))\n",
"\n",
"out_circ = pm.run(in_circ)\n",
"\n",
"in_circ.draw(output=\"mpl\")\n",
"out_circ.draw(output=\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "56b80ce3",
"metadata": {},
"source": [
"\n",
"\n",
"## Etapes suivantes\n",
"\n",
"\n",
" * Consultez le guide sur la création d'un [passage de transcompilation personnalisé](/docs/guides/custom-transpiler-pass)\n",
" * Découvrez comment [créer et transcompiler pour des backends personnalisés](/docs/guides/custom-backend)\n",
" * Consultez le guide [Comparer les paramètres du transpiler](/docs/guides/circuit-transpilation-settings).\n",
" * Consultez la [documentation relative à l'API DAG Circuit](/docs/api/qiskit/dagcircuit).\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"id": "a1b8767d",
"source": "© IBM Corp., 2017-2026"
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3"
}
},
"nbformat": 4,
"nbformat_minor": 5
}