Représenter les ordinateurs quantiques pour le transpileur

• 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
  

Pour convertir un circuit abstrait en un circuit ISA qui peut fonctionner sur une QPU (unité de traitement quantique) spécifique, le transpileur a besoin de certaines informations sur la QPU. Ces informations se trouvent à deux endroits : l'objet BackendV2 (ou l'ancien BackendV1) auquel vous prévoyez de soumettre des travaux et l'attribut Target du backend.

• Le Target contient toutes les contraintes pertinentes d'un dispositif, telles que son jeu d'instructions pris en charge, la connectivité des qubits et les informations relatives aux impulsions ou à la synchronisation.
• Le Backend possède un Target par défaut, contient des informations supplémentaires, telles que le InstructionScheduleMap, et fournit l'interface permettant de soumettre des tâches de circuit quantique.

Vous pouvez également fournir explicitement des informations au transpondeur, par exemple si vous avez un cas d'utilisation spécifique ou si vous pensez que ces informations aideront le transpondeur à générer un circuit plus optimisé.

La précision avec laquelle le transpileur produit le circuit le plus approprié pour un matériel spécifique dépend de la quantité d'informations dont dispose le site Target ou Backend sur ses contraintes.

Cette page présente plusieurs exemples de transmission d'informations QPU au transcompilateur.

Configuration par défaut

L'utilisation la plus simple du transpondeur consiste à fournir toutes les informations relatives à la QPU en fournissant le site Backend ou Target. Pour mieux comprendre le fonctionnement du transpileur, construisez un circuit et transpilez-le avec différentes informations, comme suit.

Importez les bibliothèques nécessaires et instanciez la QPU : Afin de convertir un circuit abstrait en un circuit ISA qui peut fonctionner sur un processeur spécifique, le transpileur a besoin de certaines informations sur le processeur. En règle générale, ces informations sont stockées dans les fichiers Backend ou Target fournie au transpondeur, et aucune autre information n'est nécessaire. Cependant, vous pouvez également fournir explicitement des informations à utiliser par le transpondeur, par exemple si vous avez un cas d'utilisation spécifique ou si vous pensez que ces informations aideront le transpondeur à générer un circuit plus optimisé.

Cette rubrique présente plusieurs exemples de transmission d'informations au transcompilateur.

from qiskit_ibm_runtime.fake_provider import FakeSherbrooke

backend = FakeSherbrooke()
target = backend.target

Le circuit d'exemple utilise une instance de efficient_su2 de la bibliothèque de circuits de Qiskit.

from qiskit.circuit.library import efficient_su2

qc = efficient_su2(12, entanglement="circular", reps=1)

qc.draw("mpl")

Output:

Cet exemple utilise les paramètres par défaut pour transposer vers le site backend's target, qui fournit toutes les informations nécessaires pour convertir le circuit en un circuit qui fonctionnera sur le backend.

from qiskit.transpiler import generate_preset_pass_manager

pass_manager = generate_preset_pass_manager(
    optimization_level=1, target=target, seed_transpiler=12345
)
qc_t_target = pass_manager.run(qc)
qc_t_target.draw("mpl", idle_wires=False, fold=-1)

Output:

Cet exemple est utilisé dans les sections suivantes de cette rubrique pour illustrer que la carte de couplage et le jeu d'instructions pris en charge sont les informations essentielles à transmettre au transcompilateur pour une construction optimale du circuit. Le QPU peut généralement sélectionner des paramètres par défaut pour d'autres informations qui ne sont pas transmises, telles que la synchronisation et la planification.

Carte de couplage

La carte de couplage est un graphique qui montre quels qubits sont connectés et ont donc des portes à deux qubits entre eux. Parfois, ce graphique est directionnel, ce qui signifie que les portes à deux qubits ne peuvent aller que dans une direction. Toutefois, le transpileur peut toujours inverser la direction d'une porte en ajoutant des portes supplémentaires à un qubit. Un circuit quantique abstrait peut toujours être représenté sur ce graphe, même si sa connectivité est limitée, en introduisant des portes SWAP pour déplacer l'information quantique.

Les qubits de nos circuits abstraits sont appelés qubits virtuels et ceux de la carte de couplage sont des qubits physiques. Le transpileur fournit une correspondance entre les qubits virtuels et les qubits physiques. L'une des premières étapes de la transpilation, la mise en page, permet d'établir cette correspondance.

Passez le mot-clé coupling_map en argument pour voir son effet sur le transpileur :

coupling_map = target.build_coupling_map()

pass_manager = generate_preset_pass_manager(
    optimization_level=0, coupling_map=coupling_map, seed_transpiler=12345
)
qc_t_cm_lv0 = pass_manager.run(qc)
qc_t_cm_lv0.draw("mpl", idle_wires=False, fold=-1)

Output:

Comme indiqué ci-dessus, plusieurs portes SWAP ont été insérées (chacune consistant en trois portes CX), ce qui entraînera de nombreuses erreurs sur les dispositifs actuels. Pour voir quels qubits sont sélectionnés dans la topologie réelle des qubits, utilisez le site plot_circuit_layout de Qiskit Visualizations :

from qiskit.visualization import plot_circuit_layout

plot_circuit_layout(qc_t_cm_lv0, backend, view="physical")

Output:

Cela montre que nos qubits virtuels 0-11 ont été trivialement mis en correspondance avec la ligne de qubits physiques 0-11. Revenons à la valeur par défaut (optimization_level=1), qui utilise VF2Layout si un routage est nécessaire.

pass_manager = generate_preset_pass_manager(
    optimization_level=1, coupling_map=coupling_map, seed_transpiler=12345
)
qc_t_cm_lv1 = pass_manager.run(qc)
qc_t_cm_lv1.draw("mpl", idle_wires=False, fold=-1)

Output:

Désormais, aucune porte SWAP n'est insérée et les qubits physiques sélectionnés sont les mêmes lorsque l'on utilise la classe target .

from qiskit.visualization import plot_circuit_layout

plot_circuit_layout(qc_t_cm_lv1, backend, view="physical")

Output:

Maintenant, la disposition est dans un anneau. Comme cette disposition respecte la connectivité du circuit, il n'y a pas de portes SWAP, ce qui permet d'obtenir un circuit de bien meilleure qualité pour l'exécution.

Instructions prises en charge

Chaque ordinateur quantique prend en charge un jeu d'instructions limité. Chaque porte du circuit doit être traduite en éléments de cet ensemble. Cet ensemble doit être constitué de portes à un et deux qubits qui fournissent un ensemble de portes universelles, ce qui signifie que toute opération quantique peut être décomposée en ces portes. Cette opération est effectuée par BasisTranslator et basis_gates peut être spécifiée comme argument clé du transpilateur afin de fournir ces informations.

basis_gates = list(target.operation_names)
print(basis_gates)

Output:

['sx', 'switch_case', 'if_else', 'rz', 'for_loop', 'ecr', 'id', 'reset', 'measure', 'x', 'delay']

Les portes à un qubit par défaut sur FakeSherbrooke sont rz, x, et sx, et la porte à deux qubits par défaut est ecr (résonance croisée avec écho). Les portes CX sont construites à partir de ecr portes, de sorte que sur certains QPU, ecr est définie comme la porte de base à deux qubits, tandis que sur d'autres, cx est la valeur par défaut. La ecr porte est la partie qui cx* s'enclenche*. Outre les portes de contrôle, il existe également les instructions delay``measurement et.

pass_manager = generate_preset_pass_manager(
    optimization_level=1,
    coupling_map=coupling_map,
    basis_gates=basis_gates,
    seed_transpiler=12345,
)
qc_t_cm_bg = pass_manager.run(qc)
qc_t_cm_bg.draw("mpl", idle_wires=False, fold=-1)

Output:

Notez que les CXGate objets ont été décomposés en ecr portes et en portes de base à un seul qubit.

Taux d'erreur des appareils

La classe Target peut contenir des informations sur les taux d'erreur des opérations effectuées sur l'appareil. Par exemple, le code suivant récupère les propriétés de la porte de résonance croisée échangée (ECR) entre les qubits 1 et 0 (notez que la porte ECR est directionnelle) :

target["ecr"][(1, 0)]

Output:

InstructionProperties(duration=5.333333333333332e-07, error=0.007494257741828603)

La sortie affiche la durée de la porte (en secondes) et son taux d'erreur. Pour révéler les informations d'erreur au transpondeur, construisez un modèle cible avec les modèles basis_gates et coupling_map ci-dessus et alimentez-le avec les valeurs d'erreur provenant du backend FakeSherbrooke.

from qiskit.transpiler import Target
from qiskit.circuit.controlflow import IfElseOp, SwitchCaseOp, ForLoopOp

err_targ = Target.from_configuration(
    basis_gates=basis_gates,
    coupling_map=coupling_map,
    num_qubits=target.num_qubits,
    custom_name_mapping={
        "if_else": IfElseOp,
        "switch_case": SwitchCaseOp,
        "for_loop": ForLoopOp,
    },
)

for i, (op, qargs) in enumerate(target.instructions):
    if op.name in basis_gates:
        err_targ[op.name][qargs] = target.instruction_properties(i)

Transpile avec notre nouvelle cible err_targ comme cible :

pass_manager = generate_preset_pass_manager(
    optimization_level=1, target=err_targ, seed_transpiler=12345
)
qc_t_cm_bg_et = pass_manager.run(qc)
qc_t_cm_bg_et.draw("mpl", idle_wires=False, fold=-1)

Output:

Comme la cible contient des informations sur les erreurs, la passe VF2PostLayout tente de trouver les qubits optimaux à utiliser, ce qui donne le même circuit que celui qui a été trouvé à l'origine avec les mêmes qubits physiques.

Etapes suivantes