Aller au contenu principal

Installer et utiliser des plugins de transpilation

Versions des paquets

Le code de cette page a été développé avec les dépendances suivantes. Nous recommandons d'utiliser ces versions ou des versions plus récentes.

qiskit[all]~=2.3.0
qiskit-ibm-runtime~=0.43.1

Pour faciliter le développement et la réutilisation de code de transpilation personnalisé par la communauté Qiskit, le SDK Qiskit propose une interface de plugins qui permet à des paquets Python tiers de déclarer qu'ils fournissent des fonctionnalités de transpilation étendues accessibles via Qiskit.

Actuellement, les plugins tiers peuvent enrichir la transpilation de trois façons :

  • Un plugin de phase de transpilation fournit un gestionnaire de passes pouvant remplacer l'une des 6 phases d'un gestionnaire de passes par phases prédéfini : init, layout, routing, translation, optimization et scheduling.
  • Un plugin de synthèse unitaire offre des fonctionnalités étendues pour la synthèse de portes unitaires.
  • Un plugin de synthèse de haut niveau offre des fonctionnalités étendues pour la synthèse d'« objets de haut niveau » tels que les fonctions linéaires ou les opérateurs de Clifford. Ces objets de haut niveau sont représentés par des sous-classes de la classe Operation.

Le reste de cette page explique comment lister les plugins disponibles, en installer de nouveaux et les utiliser.

Lister les plugins disponibles et en installer de nouveaux​

Qiskit intègre déjà quelques plugins de transpilation. Pour en installer d'autres, tu peux utiliser ton gestionnaire de paquets Python. Par exemple, tu peux exécuter pip install qiskit-toqm pour installer le plugin de phase de routage Qiskit TOQM. Plusieurs plugins tiers font partie de l'écosystème Qiskit.

Lister les plugins de phase de transpilation disponibles​

Utilise la fonction list_stage_plugins en lui passant le nom de la phase dont tu veux lister les plugins.

# Added by doQumentation — required packages for this notebook
!pip install -q qiskit qiskit-ibm-runtime
from qiskit.transpiler.preset_passmanagers.plugin import list_stage_plugins

list_stage_plugins("layout")
['default', 'dense', 'sabre', 'trivial']
list_stage_plugins("routing")
['basic', 'default', 'lookahead', 'none', 'sabre']

Si qiskit-toqm était installé, toqm apparaîtrait dans la liste des plugins de routing.

Lister les plugins de synthèse unitaire disponibles​

Utilise la fonction unitary_synthesis_plugin_names.

from qiskit.transpiler.passes.synthesis import unitary_synthesis_plugin_names

unitary_synthesis_plugin_names()
['aqc', 'clifford', 'default', 'gridsynth', 'sk']

Lister les plugins de synthèse de haut niveau disponibles​

Utilise la fonction high_level_synthesis_plugin_names en lui passant le nom du type d'« objet de haut niveau » à synthétiser. Ce nom correspond à l'attribut name de la classe Operation représentant le type d'objet à synthétiser.

from qiskit.transpiler.passes.synthesis import (
    high_level_synthesis_plugin_names,
)

high_level_synthesis_plugin_names("clifford")
['ag', 'bm', 'default', 'greedy', 'layers', 'lnn', 'rb_default']

Tu peux utiliser la classe HighLevelSynthesisPluginManager pour lister les noms de tous les plugins de synthèse de haut niveau :

from qiskit.transpiler.passes.synthesis.plugin import (
    HighLevelSynthesisPluginManager,
)

HighLevelSynthesisPluginManager().plugins.names()
['FullAdder.default',
 'FullAdder.ripple_c04',
 'FullAdder.ripple_v95',
 'HalfAdder.default',
 'HalfAdder.qft_d00',
 'HalfAdder.ripple_c04',
 'HalfAdder.ripple_r25',
 'HalfAdder.ripple_v95',
 'IntComp.default',
 'IntComp.noaux',
 'IntComp.twos',
 'ModularAdder.default',
 'ModularAdder.modular_v17',
 'ModularAdder.qft_d00',
 'ModularAdder.ripple_c04',
 'ModularAdder.ripple_v95',
 'Multiplier.cumulative_h18',
 'Multiplier.default',
 'Multiplier.qft_r17',
 'PauliEvolution.default',
 'PauliEvolution.rustiq',
 'WeightedSum.default',
 'annotated.default',
 'clifford.ag',
 'clifford.bm',
 'clifford.default',
 'clifford.greedy',
 'clifford.layers',
 'clifford.lnn',
 'linear_function.default',
 'linear_function.kms',
 'linear_function.pmh',
 'mcmt.default',
 'mcmt.noaux',
 'mcmt.vchain',
 'mcmt.xgate',
 'mcx.1_clean_b95',
 'mcx.1_clean_kg24',
 'mcx.1_dirty_kg24',
 'mcx.2_clean_kg24',
 'mcx.2_dirty_kg24',
 'mcx.default',
 'mcx.gray_code',
 'mcx.n_clean_m15',
 'mcx.n_dirty_i15',
 'mcx.noaux_hp24',
 'mcx.noaux_v24',
 'permutation.acg',
 'permutation.basic',
 'permutation.default',
 'permutation.kms',
 'permutation.token_swapper',
 'qft.default',
 'qft.full',
 'qft.line',
 'clifford.rb_default']

Utiliser un plugin​

Dans cette section, nous montrons comment utiliser des plugins de transpilation. Les exemples de code utilisent des plugins fournis avec Qiskit, mais les plugins installés depuis des paquets tiers s'utilisent de la même façon.

Utiliser un plugin de phase de transpilation​

Pour utiliser un plugin de phase de transpilation, indique son nom dans l'argument approprié de generate_preset_pass_manager ou de transpile. Cet argument se forme en ajoutant _method au nom de la phase de transpilation. Par exemple, pour utiliser le plugin de routage lookahead, on passe lookahead à l'argument routing_method :

from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
backend = service.backend("ibm_fez")

pass_manager = generate_preset_pass_manager(
    optimization_level=3, backend=backend, routing_method="lookahead"
)

Utiliser un plugin de synthèse unitaire​

Pour utiliser un plugin de synthèse unitaire, indique son nom dans l'argument unitary_synthesis_method de generate_preset_pass_manager ou de transpile :

pass_manager = generate_preset_pass_manager(
    optimization_level=3,
    backend=backend,
    unitary_synthesis_method="sk",
    unitary_synthesis_plugin_config=dict(
        basis_gates=["cz", "id", "rz", "sx", "x"]
    ),
)

La synthèse unitaire est utilisée dans les phases init, translation et optimization du gestionnaire de passes par phases retourné par generate_preset_pass_manager ou utilisé dans transpile. Consulte Phases du transpiler pour une description de ces phases.

Utilise l'argument unitary_synthesis_plugin_config, un dictionnaire libre, pour passer des options à la méthode de synthèse unitaire. La documentation de la méthode de synthèse doit expliquer les options qu'elle prend en charge. Consulte cette liste pour accéder à la documentation des plugins de synthèse unitaire intégrés.

Utiliser un plugin de synthèse de haut niveau​

Commence par créer un objet HLSConfig pour stocker les noms des plugins à utiliser pour différents objets de haut niveau. Par exemple :

from qiskit.transpiler.passes import HLSConfig

hls_config = HLSConfig(clifford=["layers"], linear_function=["pmh"])

Ce bloc de code crée une configuration de synthèse de haut niveau qui utilise le plugin layers pour synthétiser des objets Clifford et le plugin pmh pour synthétiser des objets LinearFunction. Les noms des arguments nommés correspondent à l'attribut name de la classe Operation représentant le type d'objet à synthétiser. Pour chaque objet de haut niveau, les plugins de la liste sont essayés dans l'ordre jusqu'à ce que l'un d'eux réussisse (dans l'exemple ci-dessus, chaque liste ne contient qu'un seul plugin).

En plus de spécifier un plugin par son nom, tu peux également passer un tuple (nom, options), où le second élément est un dictionnaire contenant les options du plugin. La documentation de la méthode de synthèse doit expliquer les options qu'elle prend en charge. Consulte cette liste pour accéder à la documentation des plugins de synthèse de haut niveau intégrés.

Une fois l'objet HLSConfig créé, passe-le via l'argument hls_config à generate_preset_pass_manager ou à transpile :

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

La synthèse de haut niveau est utilisée dans les phases init, translation et optimization du gestionnaire de passes par phases retourné par generate_preset_pass_manager ou utilisé dans transpile. Consulte Phases du transpiler pour une description de ces phases.

Prochaines étapes​

Recommandation