{ "cells": [ { "cell_type": "markdown", "id": "83596f71-5e63-4aa2-907b-75de8813d85a", "metadata": {}, "source": [ "---\n", "title: \"Exécuter des circuits dynamiques\"\n", "description: \"Utilisez le service de calcul « IBM Quantum » pour les circuits classiques à action directe et de contrôle de flux, également appelés « circuits dynamiques »\"\n", "---\n", "\n", "\n", "\n", "# Exécuter des circuits dynamiques\n", "\n" ] }, { "cell_type": "markdown", "id": "2228a8a2-02b7-4a0b-bbe8-0c2933fbe44a", "metadata": {}, "source": [ "Les circuits dynamiques sont des outils puissants qui permettent de mesurer des qubits au cours de l'exécution d'un circuit quantique, puis d'effectuer des opérations logiques classiques au sein du circuit, en fonction des résultats de ces mesures intermédiaires. Ce processus est également connu sous le nom de «\\* feedforward classique\\* ». Même si l'on n'en est qu'aux prémices de la compréhension des meilleures façons de tirer parti des circuits dynamiques, la communauté des chercheurs en physique quantique a déjà identifié un certain nombre de cas d'application, tels que les suivants :\n", "\n", "* La préparation efficace d'états quantiques, tels que [l'état GHZ](https://journals.aps.org/prxquantum/abstract/10.1103/PRXQuantum.5.030339), [l'état W](https://arxiv.org/abs/2403.07604) (pour plus d'informations sur l'état W, voir également [« Préparation d'états par des circuits peu profonds utilisant la transmission directe »](https://arxiv.org/abs/2307.14840) ) et une large classe [d'états de produits matriciels](https://arxiv.org/abs/2404.16083)\n", "* [Intrication efficace à longue portée](https://journals.aps.org/prxquantum/abstract/10.1103/PRXQuantum.5.030339) entre des qubits situés sur la même puce grâce à l'utilisation de circuits peu profonds\n", "* [Échantillonnage](https://arxiv.org/pdf/2505.04705) efficace des circuits de type IQP\n", "\n", "Ces améliorations apportées par les circuits dynamiques s'accompagnent toutefois de compromis. Les mesures en cours de circuit et les opérations classiques ont généralement un temps d'exécution plus long que les portes à deux qubits, et cette augmentation du temps pourrait annuler les avantages liés à la réduction de la profondeur du circuit. C'est pourquoi la réduction de la durée des mesures en cours de circuit constitue un axe prioritaire d'amélioration alors qu' IBM Quantum® s'apprête à lancer la [nouvelle version](/docs/guides/changelog-quantum-compute-service#new-version-dynamic-circuits) de ses circuits dynamiques. Pour connaître les autres restrictions liées à l'utilisation des circuits dynamiques, consultez le tableau de compatibilité des fonctionnalités « [Estimator ](/docs/guides/estimator-options#options-compatibility-table)» et « [Sampler](/docs/guides/sampler-options#options-compatibility-table) ».\n", "\n", "La [spécification « OpenQASM e 3](https://openqasm.com/language/classical.html#looping-and-branching) » définit plusieurs structures de contrôle de flux, mais le service de calcul d’ IBM Quantum ne prend actuellement en charge que l’instruction `if` conditionnelle. Dans « Qiskit SDK », cela correspond à la méthode [`if_test` disponible](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#if_test) sur [QuantumCircuit](/docs/api/qiskit/qiskit.circuit.QuantumCircuit). Cette méthode renvoie un [gestionnaire de contexte](https://docs.python.org/3/reference/datamodel.html#with-statement-context-managers) et est généralement utilisée dans une instruction `with` . Ce guide explique comment utiliser cette instruction conditionnelle.\n", "\n", "\n", " Les exemples de code présentés dans ce guide utilisent l'instruction de mesure standard pour les mesures en cours de circuit. Il est toutefois recommandé d'utiliser plutôt `MidCircuitMeasure` l'instruction, si le backend la prend en charge. Pour plus de détails, consultez la [section « Mesures en cours de circuit](#midcircuit) ».\n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "7e9dc06d-85fa-4425-9bd1-ce5085be9741", "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 présenté sur cette page a été développé en tenant compte des exigences suivantes.\n", " Nous vous recommandons d'utiliser ces versions ou des versions plus récentes.\n", "\n", " ```\n", " qiskit[all]~=2.5.1\n", " qiskit-ibm-runtime~=0.47.0\n", " ```\n", " \n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "c4616d43-f296-4a84-a79c-deb37fcdac15", "metadata": {}, "source": [ "\n", "\n", "## Trouver des backends prenant en charge les circuits dynamiques\n", "\n", "Pour répertorier tous les backends auxquels votre compte a accès et qui prennent en charge les circuits dynamiques, exécutez un code similaire à celui-ci. Cet exemple part du principe que vous avez [enregistré vos identifiants de connexion](/docs/guides/save-credentials). Vous pouvez également [indiquer explicitement vos identifiants](/docs/guides/initialize-account#explicit) lors de l'initialisation de votre compte du service Compute d' IBM Quantum. Cela vous permettrait, par exemple, de consulter les backends disponibles sur une instance spécifique ou pour un type de forfait donné.\n", "\n", "\n", " * Les backends disponibles pour le compte dépendent de l'instance indiquée dans les informations d'identification.\n", " * La nouvelle version des circuits dynamiques est désormais disponible pour tous les utilisateurs sur tous les backends. Consultez [l'annonce](/docs/guides/changelog-quantum-compute-service#new-dynamic-circuits) pour plus de détails.\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "a63f07b1-9e8a-4086-ab01-552bd444dc9b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[, , , , ]\n" ] } ], "source": [ "from qiskit_ibm_runtime import QiskitRuntimeService\n", "\n", "service = QiskitRuntimeService()\n", "dc_backends = service.backends(dynamic_circuits=True)\n", "print(dc_backends)" ] }, { "cell_type": "markdown", "id": "1dca7d79-99ea-42bd-86f7-182266907a85", "metadata": {}, "source": [ "\n", "\n", "\n", "\n", "## Mesures en cours de circuit\n", "\n", "Avant l'introduction de `qiskit-ibm-runtime` `v0.43.0`, `measure` c'était la seule instruction de mesure disponible dans Qiskit. Les mesures en cours de circuit ont toutefois des exigences de réglage différentes de celles des mesures *aux bornes* (mesures effectuées à l'extrémité d'un circuit). Par exemple, il faut tenir compte de la durée des instructions lors du réglage d'une mesure en cours de circuit, car des instructions plus longues entraînent davantage de bruit dans les circuits. Il n'est pas nécessaire de tenir compte de la durée des instructions pour les mesures de terminaison, car aucune instruction ne suit ces mesures.\n", "\n", "\n", " L'instruction `MidCircuitMeasure` correspond à `measure_2` l'instruction indiquée dans le fichier. du backend `supported_instructions`. Cependant, cette `measure_2` fonctionnalité n'est pas prise en charge par tous les backends. Utilisez `service.backends(filters=lambda b: \"measure_2\" in b.supported_instructions)` pour trouver les backends qui le prennent en charge. D'autres mesures pourraient être ajoutées à l'avenir, mais cela n'est pas garanti.\n", "\n", "\n", "\n", "\n", "### `MidCircuitMeasure`méthode\n", "\n", "Dans la version `qiskit-ibm-runtime` v0.43.0, cette `MidCircuitMeasure` instruction a été introduite. Comme son nom l'indique, il s'agit d'une nouvelle instruction de calcul optimisée pour l'exécution en milieu de circuit sur les QPU d' IBM®. Bien que vous puissiez utiliser `QuantumCircuit.measure` pour une mesure à mi-circuit, en raison de sa conception, `MidCircuitMeasure` constitue généralement un meilleur choix. Par exemple, cela alourdit moins votre circuit que lorsque vous utilisez `QuantumCircuit.measure`.\n", "\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "87dfb9c7-1dc2-4752-bdc1-17b9144369f4", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " ┌───┐┌────────────┐\n", "q_0: ┤ X ├┤0 ├\n", " └───┘│ │\n", "q_1: ─────┤ Measure_2 ├\n", " │ │\n", "c_0: ═════╡0 ╞\n", " └────────────┘\n", "c_1: ═══════════════════\n", " \n" ] } ], "source": [ "from qiskit import QuantumCircuit\n", "from qiskit_ibm_runtime import QiskitRuntimeService\n", "from qiskit_ibm_runtime.circuit import MidCircuitMeasure\n", "\n", "service = QiskitRuntimeService()\n", "backend = service.least_busy(\n", " operational=True, simulator=False, dynamic_circuits=True\n", ")\n", "\n", "circ = QuantumCircuit(2, 2)\n", "circ.x(0)\n", "circ.append(MidCircuitMeasure(), [0], [0])\n", "# circ.measure([0], [0])\n", "# circ.measure_all()\n", "print(circ.draw(cregbundle=False))" ] }, { "cell_type": "markdown", "id": "2b603f88-2e0e-4819-8342-8e3662949ff3", "metadata": {}, "source": [ "\n", " * Il faut qu'il y ait au moins un registre classique pour pouvoir utiliser les mesures.\n", " * La primitive Sampler nécessite des mesures de circuit. Vous pouvez ajouter des mesures de circuit à l'aide de la primitive Estimator, mais celles-ci sont ignorées.\n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "9401a5cc-49e0-48b6-8deb-88e9b7da5a5a", "metadata": {}, "source": [ "\n", "\n", "## `Store`\n", "\n", "À partir de `qiskit-ibm-runtime` la version 0.47.0, vous pouvez utiliser l'instruction [`store`](/docs/api/qiskit/circuit#store) pour enregistrer le résultat d'une expression classique, si celle-ci doit être réutilisée à plusieurs reprises. Les opérations sont automatiquement parallélisées, ce qui rend votre code nettement plus efficace lors de l'exécution.\n", "\n", "Pour plus d'informations, consultez le guide [sur les circuits de commande classiques à action directe et le flux de contrôle](/docs/guides/classical-feedforward-and-control-flow#store).\n", "\n", "\n", " Lorsque vous utilisez `store` pour enregistrer une valeur dans un registre classique sur un backend réel, cette valeur n'est conservée en mémoire que pendant l'exécution; elle n'est ni copiée ni renvoyée dans le résultat de la tâche.\n", "\n", " `if_test` Par exemple, dans le code suivant, `temp` a la même valeur que `creg` lors de l'exécution, et fonctionne comme prévu. Mais une fois la tâche terminée, l' `temp`BitArray e renvoyée dans le résultat de la tâche **ne** contient pas la valeur de `creg`. Autrement dit, `job.result()[0].data.temp` est `0`.\n", "\n", " ```python\n", " creg = ClassicalRegister(3, \"c\")\n", " temp = ClassicalRegister(3, \"temp\")\n", " ...\n", " qc.store(temp, creg)\n", " with circuit.if_test((temp, 0b001)):\n", " ...\n", " ```\n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "3f374a74-c331-40de-8594-686e471058a2", "metadata": {}, "source": [ "\n", "\n", "## Exemple complet\n", "\n", "Le code suivant permet de créer et d'exécuter un circuit dynamique sur le matériel d' IBM®.\n", "\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "a7a9c998-4031-432f-978b-83edc040798f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ ">>> Job ID: d9mq9qnurbec73e67acg (DONE)\n" ] } ], "source": [ "from qiskit_ibm_runtime import SamplerV2, QiskitRuntimeService\n", "from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister\n", "from qiskit.transpiler import generate_preset_pass_manager\n", "\n", "service = QiskitRuntimeService()\n", "backend = service.least_busy(\n", " operational=True, simulator=False, dynamic_circuits=True\n", ")\n", "\n", "# Create a dynamic circuit\n", "\n", "qubits = QuantumRegister(1)\n", "clbits = ClassicalRegister(1)\n", "qc = QuantumCircuit(qubits, clbits)\n", "(q0,) = qubits\n", "(c0,) = clbits\n", "\n", "qc.h(q0)\n", "qc.measure(q0, c0)\n", "with qc.if_test((c0, 1)):\n", " qc.x(q0)\n", "qc.measure(q0, c0)\n", "\n", "\n", "# Convert to an ISA circuit for the given backend\n", "\n", "pm = generate_preset_pass_manager(backend=backend, optimization_level=1)\n", "isa_circuit = pm.run(qc)\n", "\n", "# Generate samplers for backend targets\n", "sampler = SamplerV2(backend)\n", "\n", "# Submit jobs\n", "sampler_job = sampler.run([isa_circuit])\n", "result = sampler_job.result()\n", "\n", "print(\n", " f\">>> {' Job ID:':<10} {sampler_job.job_id()} ({sampler_job.status()})\"\n", ")" ] }, { "cell_type": "markdown", "id": "c5b14dcf-edf4-4fef-bb49-e6b86f06afb0", "metadata": {}, "source": [ "\n", "\n", "## Limites de l'informatique quantique\n", "\n", "Tenez compte des contraintes suivantes lors de l'exécution de circuits dynamiques dans Quantum Compute.\n", "\n", "* En raison de la mémoire physique limitée des composants électroniques de commande, le nombre `if` d'instructions et la taille de leurs opérandes sont également limités. Cette limite dépend du nombre de diffusions et du nombre de bits diffusés dans une tâche (et non dans un circuit).\n", "\n", " Lors du traitement d'une `if` condition, les données de mesure doivent être transmises à la logique de commande afin de permettre cette évaluation. Une diffusion correspond au transfert de données classiques uniques, et le nombre de bits diffusés correspond au nombre de bits classiques transférés. Tenez compte des éléments suivants :\n", "\n", " ```python\n", " c0 = ClassicalRegister(3)\n", " c1 = ClassicalRegister(5)\n", " ...\n", " with circuit.if_test((c0, 1)) ...\n", " with circuit.if_test((c0, 3)) ...\n", " with circuit.if_test((c1[2], 1)) ...\n", " ```\n", "\n", " Dans l'exemple de code précédent, les deux premiers `if_test` objets de `c0` sont considérés comme une seule diffusion, car le contenu de `c0` n'a pas changé et n'a donc pas besoin d'être rediffusé. Il `c1``if_test` s'agit d'une rediffusion. Le premier diffuse les trois bits, `c0` tandis que le second n'en diffuse qu'un seul, ce qui fait un total de quatre bits diffusés.\n", "\n", " Actuellement, si vous diffusez 60 bits à chaque fois, la tâche peut comporter environ 300 diffusions. Si, en revanche, vous ne transmettez qu'un seul bit à chaque fois, la tâche peut alors comporter 2 400 transmissions.\n", "\n", "* L'opérande utilisé dans une `if_test` instruction doit comporter 32 bits ou moins. Ainsi, si vous comparez un entier `ClassicalRegister`, la taille de celui-ci `ClassicalRegister` doit être de 32 bits ou moins. Si vous ne comparez qu'un seul bit d'un `ClassicalRegister`, celui-ci `ClassicalRegister` peut toutefois être de n'importe quelle taille (puisque l'opérande ne comporte qu'un seul bit).\n", "\n", " Par exemple, le bloc de code « Non valide » ne fonctionne pas car `cr` dépasse 32 bits. Vous pouvez toutefois utiliser un registre classique de plus de 32 bits si vous ne testez qu'un seul bit, comme le montre le bloc de code « Valid ».\n", "\n", " \n", " \n", " ```python\n", " cr = ClassicalRegister(50)\n", " qr = QuantumRegister(50)\n", " circuit = QuantumCircuit(qr, cr)\n", " ...\n", " circ.measure(qr, cr)\n", " with circ.if_test((cr, 15)):\n", " ...\n", " ```\n", " \n", "\n", " \n", " ```python\n", " cr = ClassicalRegister(50)\n", " qr = QuantumRegister(50)\n", " circuit = QuantumCircuit(qr, cr)\n", " ...\n", " circ.measure(qr, cr)\n", " with circ.if_test((cr[5], 1)):\n", " ...\n", " ```\n", " \n", " \n", "\n", "* Les conditions imbriquées ne sont pas autorisées. Par exemple, le bloc de code suivant ne fonctionnera pas car il contient un `if_test` à l'intérieur d'un autre `if_test`:\n", "\n", " \n", " \n", " ```python\n", " c1 = ClassicalRegister(1, \"c1\")\n", " c2 = ClassicalRegister(2, \"c2\")\n", " ...\n", " with circ.if_test((c1, 1)):\n", " with circ.if_test(c2, 1)):\n", " ...\n", " ```\n", " \n", "\n", " \n", " ```python\n", " cr = ClassicalRegister(2)\n", " ...\n", " with circuit.if_test((cr, 0b11)):\n", " ...\n", " ```\n", " \n", " \n", "\n", "* L'utilisation de `reset` ou de mesures à l'intérieur de conditions n'est pas prise en charge.\n", "\n", "* Les opérations arithmétiques ne sont pas prises en charge.\n", "\n", "* Consultez le [tableau des fonctionnalités d' OpenQASM e 3](/docs/guides/qasm-feature-table) pour déterminer quelles fonctionnalités d' OpenQASM e 3 sont prises en charge par Qiskit et Quantum Compute.\n", "\n", "* Lorsque le format d'entrée « OpenQASM 3 » (au lieu de `QuantumCircuit`) est utilisé pour transmettre des circuits aux primitives de type « IBM Quantum », seules les instructions pouvant être chargées dans Qiskit sont prises en charge. Les opérations classiques, par exemple, ne sont pas prises en charge car elles ne peuvent pas être chargées dans Qiskit. Pour plus d'informations, consultez la section « [Importer un programme d' OpenQASM ie 3 dans Qiskit](/docs/guides/interoperate-qiskit-qasm3#import-an-openqasm-3-program-into-qiskit) ».\n", "\n", "* Les commandes `for`, `while``switch` , et ne sont pas prises en charge.\n", "\n" ] }, { "cell_type": "markdown", "id": "ca6e0493-d364-40bf-9f47-2e3feed9f82c", "metadata": {}, "source": [ "\n", "\n", "## Utiliser des circuits dynamiques avec Estimator\n", "\n", "Comme Estimator ne prend pas en charge les circuits dynamiques, vous pouvez utiliser [Sampler](/docs/guides/get-started-with-sampler) et créer vos propres circuits de mesure à la place.\n", "\n", "Pour reproduire le comportement d'Estimator, procédez comme suit :\n", "\n", "1. Regroupez les termes de toutes les observables dans une partition. Pour ce faire, on peut par exemple utiliser le [`PauliList` API](/docs/api/qiskit/qiskit.quantum_info.PauliList#group_qubit_wise_commuting).\n", " \n", " Vous pouvez utiliser l'attribut « [`BitArray`](/docs/en/api/qiskit/qiskit.primitives.BitArray#expectation_values) primitive » pour calculer les valeurs attendues des observables fournies.\n", " \n", "2. Effectuer un cycle de changement de base par partition (quel que soit le changement de base à effectuer pour chaque partition). Pour plus d'informations, consultez le [module `measurement_bases`](https://qiskit.github.io/qiskit-addon-utils/apidocs/qiskit_addon_utils.exp_vals.html#qiskit_addon_utils.exp_vals.get_measurement_bases) utilitaire « Measurement bases ». Pour plus d'informations, consultez la [documentation](https://qiskit.github.io/qiskit-addon-utils/) relative au package d'utilitaires du module complémentaire Qiskit.\n", "3. Additionnez les résultats obtenus pour chaque partition.\n", "\n" ] }, { "cell_type": "markdown", "id": "07045397-6db8-4151-a1e4-de24a8f39ab6", "metadata": {}, "source": [ "\n", "\n", "## Restrictions\n", "\n", "Consultez [le tableau de compatibilité des](/docs/guides/estimator-options#options-compatibility-table) fonctionnalités pour connaître les restrictions liées à l'utilisation des circuits dynamiques. Notez que la compatibilité des fonctionnalités ne dépend pas des primitives.\n", "\n" ] }, { "cell_type": "markdown", "id": "6688e2e3-766b-4194-99db-ae097e9b8bc7", "metadata": {}, "source": [ "\n", "\n", "## Etapes suivantes\n", "\n", "\n", " * Découvrez comment mettre en œuvre un découplage dynamique précis à l'aide de [stretch](/docs/guides/stretch).\n", " * Consultez le guide [sur les circuits de commande classiques à action directe et le flux de contrôle](/docs/guides/classical-feedforward-and-control-flow).\n", " * Utilisez [la visualisation du schéma de circuit](/docs/guides/qiskit-runtime-circuit-timing) pour déboguer et optimiser vos circuits dynamiques.\n", " * Toutes les fonctions ne sont pas compatibles avec les circuits dynamiques. Pour plus d'informations, consultez la section « Compatibilité des fonctionnalités » de [Sampler](/docs/guides/sampler-options#feature-compatibility).\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": 4 }