Transpiler avec gestionnaires de passes

• Versions de package

  Le code de cette page a été développé en tenant compte des exigences suivantes. Nous recommandons d'utiliser ces versions ou des versions plus récentes.

  qiskit[all]~=2.5.1
  qiskit-ibm-runtime~=0.47.0
  

La méthode recommandée pour transpiler un circuit consiste à créer un gestionnaire de passes par étapes, puis à exécuter sa méthode run avec le circuit en entrée. Cette page explique comment transposer les circuits quantiques de cette manière.

Qu'est-ce qu'un gestionnaire de passe (étagé)?

Dans le contexte du SDK Qiskit, la transpilation fait référence au processus de transformation d'un circuit d'entrée en une forme adaptée à l'exécution sur un dispositif quantique. La transpilation s'effectue généralement en une série d'étapes appelées "passes de transpilation". Le circuit est traité par chaque passage du transpondeur en séquence, la sortie d'un passage devenant l'entrée du suivant. Par exemple, une passe pourrait parcourir le circuit et fusionner toutes les séquences consécutives de portes à qubit unique, puis la passe suivante pourrait synthétiser ces portes dans l'ensemble de base du dispositif cible. Les passes de transpilation incluses avec Qiskit sont situées dans le module qiskit.transpiler.passes module.

Un gestionnaire de passes est un objet qui stocke une liste de passes de transpondeur et peut les exécuter sur un circuit. Créer un gestionnaire de passes en initialisant un PassManager avec une liste de passes de transpilateur. Pour exécuter la transpilation sur un circuit, appelez la méthode run avec un circuit en entrée.

Un gestionnaire de passe par étapes est un type spécial de gestionnaire de passe qui représente un niveau d'abstraction supérieur à celui d'un gestionnaire de passe normal. Alors qu'un gestionnaire de laissez-passer normal est composé de plusieurs laissez-passer de transpondeur, un gestionnaire de laissez-passer par étapes est composé de plusieurs gestionnaires de laissez-passer. Il s'agit d'une abstraction utile car la transpilation s'effectue généralement par étapes discrètes, comme décrit dans les étapes du transpilateur, chaque étape étant représentée par un gestionnaire de passes. Les gestionnaires de passages échelonnés sont représentés par la classe StagedPassManager classe. Le reste de cette page décrit comment créer et personnaliser les gestionnaires de passe (par étapes).

Générer un gestionnaire de passes prédéfini

Pour créer un gestionnaire de passes par étapes prédéfini avec des valeurs par défaut raisonnables, utilisez la generate_preset_pass_manager fonction.

from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime.fake_provider import FakeSherbrooke

backend = FakeSherbrooke()
pass_manager = generate_preset_pass_manager(
    optimization_level=3, backend=backend
)

Pour transpiler un circuit ou une liste de circuits avec un gestionnaire de passage, passez le circuit ou la liste de circuits à la méthode run . Nous allons le faire sur un circuit à deux qubits composé d'un Hadamard suivi de deux portes CX adjacentes :

from qiskit import QuantumRegister, QuantumCircuit

# Create a circuit
qubits = QuantumRegister(2, name="q")
circuit = QuantumCircuit(qubits)
a, b = qubits
circuit.h(a)
circuit.cx(a, b)
circuit.cx(b, a)

# Transpile it by calling the run method of the pass manager
transpiled = pass_manager.run(circuit)

# Draw it, excluding idle qubits from the diagram
transpiled.draw("mpl", idle_wires=False)

Output:

Voir les options de configuration et les valeurs par défaut de la transpilation pour une description des arguments possibles de la fonction generate_preset_pass_manager . Les arguments de generate_preset_pass_manager correspondent aux arguments de la fonction transpile de la fonction.

Si les gestionnaires de passe prédéfinis ne répondent pas à vos besoins, personnalisez la transpilation en créant des gestionnaires de passe (échelonnés) ou même des passes de transpilation. Le reste de cette page décrit comment créer des gestionnaires de passe. Pour savoir comment créer des passes de transpilation, voir Rédiger votre propre passe de transpilation.

Créez votre propre gestionnaire de passes

Le module qiskit.transpiler.passes comprend de nombreuses passes de transpilation qui peuvent être utilisées pour créer des gestionnaires de passes. Pour créer un gestionnaire de laissez-passer, initialisez un site PassManager avec une liste de laissez-passer. Par exemple, le code suivant crée une passe de transpilation qui fusionne des portes adjacentes à deux qubits, puis les synthétise dans une base de $R_y$, $R_z$, et $R_{xx}$ et de portes,.

from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import (
    Collect2qBlocks,
    ConsolidateBlocks,
    UnitarySynthesis,
)

basis_gates = ["rx", "ry", "rxx"]
translate = PassManager(
    [
        Collect2qBlocks(),
        ConsolidateBlocks(basis_gates=basis_gates),
        UnitarySynthesis(basis_gates),
    ]
)

Pour démontrer l'efficacité de ce gestionnaire de passage, nous le testons sur un circuit à deux qubits composé d'un Hadamard suivi de deux portes CX adjacentes :

from qiskit import QuantumRegister, QuantumCircuit

qubits = QuantumRegister(2, name="q")
circuit = QuantumCircuit(qubits)

a, b = qubits
circuit.h(a)
circuit.cx(a, b)
circuit.cx(b, a)

circuit.draw("mpl")

Output:

Pour exécuter le gestionnaire de passe sur le circuit, appelez la méthode run .

translated = translate.run(circuit)
translated.draw("mpl")

Output:

Pour un exemple plus avancé qui montre comment créer un gestionnaire de passe pour mettre en œuvre la technique de suppression des erreurs connue sous le nom de découplage dynamique, voir Créer un gestionnaire de passe pour le découplage dynamique.

Créer un gestionnaire de passes par étapes

Un site StagedPassManager est un gestionnaire de passage composé d'étapes individuelles, chaque étape étant définie par une instance PassManager . Vous pouvez créer un site StagedPassManager en spécifiant les étapes souhaitées. Par exemple, le code suivant crée un gestionnaire de passes par étapes avec deux étapes, init et translation. L'étape translation est définie par le gestionnaire de passe créé précédemment.

from qiskit.transpiler import PassManager, StagedPassManager
from qiskit.transpiler.passes import UnitarySynthesis, Unroll3qOrMore

basis_gates = ["rx", "ry", "rxx"]
init = PassManager(
    [UnitarySynthesis(basis_gates, min_qubits=3), Unroll3qOrMore()]
)
staged_pm = StagedPassManager(
    stages=["init", "translation"], init=init, translation=translate
)

Il n'y a pas de limite au nombre d'étapes que vous pouvez mettre dans un gestionnaire de passes par étapes.

Une autre façon utile de créer un gestionnaire de laissez-passer par étapes consiste à commencer par un gestionnaire de laissez-passer par étapes prédéfini, puis à intervertir certaines des étapes. Par exemple, le code suivant génère un gestionnaire de passe prédéfini avec un niveau d'optimisation 3, puis spécifie une étape personnalisée pre_layout .

import numpy as np
from qiskit.circuit.library import HGate, PhaseGate, RXGate, TdgGate, TGate
from qiskit.transpiler.passes import InverseCancellation

pass_manager = generate_preset_pass_manager(3, backend)
inverse_gate_list = [
    HGate(),
    (RXGate(np.pi / 4), RXGate(-np.pi / 4)),
    (PhaseGate(np.pi / 4), PhaseGate(-np.pi / 4)),
    (TGate(), TdgGate()),
]
logical_opt = PassManager(
    [
        InverseCancellation(inverse_gate_list),
    ]
)

# Add pre-layout stage to run extra logical optimization
pass_manager.pre_layout = logical_opt

Les fonctions du générateur d'étapes peuvent être utiles pour construire des gestionnaires de passe personnalisés. Ils génèrent des étapes qui fournissent des fonctionnalités communes utilisées dans de nombreux gestionnaires de passe. Par exemple, generate_embed_passmanager peut être utilisé pour générer une étape pour "incorporer" un site initial sélectionné Layout à partir d'un passage de mise en page vers le dispositif cible spécifié.

Etapes suivantes