Zum Hauptinhalt springen

Transpiler-Plugins installieren und verwenden

Paketversionen

Der Code auf dieser Seite wurde mit den folgenden Anforderungen entwickelt. Wir empfehlen die Verwendung dieser oder neuerer Versionen.

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

Um die Entwicklung und Wiederverwendung von benutzerdefiniertem Transpilierungscode durch die breitere Qiskit-Community zu erleichtern, unterstützt das Qiskit SDK eine Plugin-Schnittstelle, die es Python-Paketen von Drittanbietern ermöglicht, erweiterte Transpilierungsfunktionen bereitzustellen, die über Qiskit zugänglich sind.

Derzeit können Drittanbieter-Plugins erweiterte Transpilierungsfunktionen auf drei Arten bereitstellen:

  • Ein Transpiler-Stage-Plugin stellt einen Pass Manager bereit, der anstelle einer der 6 Stufen eines voreingestellten gestuften Pass Managers verwendet werden kann: init, layout, routing, translation, optimization und scheduling.
  • Ein Unitary-Synthesis-Plugin bietet erweiterte Funktionen für die unitäre Gate-Synthese.
  • Ein High-Level-Synthesis-Plugin bietet erweiterte Funktionen für die Synthese von „High-Level-Objekten" wie linearen Funktionen oder Clifford-Operatoren. High-Level-Objekte werden durch Unterklassen der Operation-Klasse dargestellt.

Der Rest der Seite beschreibt, wie du verfügbare Plugins auflistest, neue installierst und sie verwendest.

Verfügbare Plugins auflisten und neue installieren​

Qiskit enthält bereits einige integrierte Plugins für die Transpilierung. Um weitere zu installieren, kannst du deinen Python-Paketmanager verwenden. Zum Beispiel kannst du pip install qiskit-toqm ausführen, um das Qiskit TOQM-Routing-Stage-Plugin zu installieren. Einige Drittanbieter-Plugins sind Teil des Qiskit-Ökosystems.

Verfügbare Transpiler-Stage-Plugins auflisten​

Verwende die Funktion list_stage_plugins und übergib den Namen der Stufe, deren Plugins du auflisten möchtest.

# 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']

Wenn qiskit-toqm installiert wäre, würde toqm in der Liste der routing-Plugins erscheinen.

Verfügbare Unitary-Synthesis-Plugins auflisten​

Verwende die Funktion unitary_synthesis_plugin_names.

from qiskit.transpiler.passes.synthesis import unitary_synthesis_plugin_names

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

Verfügbare High-Level-Synthesis-Plugins auflisten​

Verwende die Funktion high_level_synthesis_plugin_names und übergib den Namen des Typs des zu synthetisierenden „High-Level-Objekts". Der Name entspricht dem name-Attribut der Operation-Klasse, die den Typ des zu synthetisierenden Objekts darstellt.

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']

Du kannst die Klasse HighLevelSynthesisPluginManager verwenden, um die Namen aller High-Level-Synthesis-Plugins aufzulisten:

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']

Ein Plugin verwenden​

In diesem Abschnitt zeigen wir, wie du Transpiler-Plugins verwendest. In den Code-Beispielen verwenden wir Plugins, die mit Qiskit mitgeliefert werden, aber Plugins aus Drittanbieter-Paketen werden auf dieselbe Weise genutzt.

Ein Transpiler-Stage-Plugin verwenden​

Um ein Transpiler-Stage-Plugin zu verwenden, gib seinen Namen mit dem entsprechenden Argument für generate_preset_pass_manager oder transpile an. Das Argument wird gebildet, indem _method an den Namen der Transpilierungsstufe angehängt wird. Um zum Beispiel das lookahead-Routing-Plugin zu verwenden, gibst du lookahead für das Argument routing_method an:

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"
)

Ein Unitary-Synthesis-Plugin verwenden​

Um ein Unitary-Synthesis-Plugin zu verwenden, gib seinen Namen als unitary_synthesis_method-Argument für generate_preset_pass_manager oder transpile an:

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"]
    ),
)

Unitary Synthesis wird in den Stufen init, translation und optimization des gestuften Pass Managers verwendet, der von generate_preset_pass_manager zurückgegeben oder in transpile verwendet wird. Siehe Transpiler-Stufen für eine Beschreibung dieser Stufen.

Verwende das Argument unitary_synthesis_plugin_config, ein frei definierbares Dictionary, um Optionen für die Unitary-Synthesis-Methode zu übergeben. Die Dokumentation der Synthesemethode sollte erklären, welche Optionen sie unterstützt. Siehe diese Liste für Links zur Dokumentation der integrierten Unitary-Synthesis-Plugins.

Ein High-Level-Synthesis-Plugin verwenden​

Erstelle zunächst ein HLSConfig-Objekt, um die Namen der Plugins zu speichern, die für verschiedene High-Level-Objekte verwendet werden sollen. Zum Beispiel:

from qiskit.transpiler.passes import HLSConfig

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

Diese Code-Zelle erstellt eine High-Level-Synthesis-Konfiguration, die das layers-Plugin für die Synthese von Clifford-Objekten und das pmh-Plugin für die Synthese von LinearFunction-Objekten verwendet. Die Namen der Schlüsselwortargumente entsprechen dem name-Attribut der Operation-Klasse, die den Typ des zu synthetisierenden Objekts darstellt. Für jedes High-Level-Objekt werden die angegebenen Plugins der Reihe nach ausprobiert, bis eines davon erfolgreich ist (im obigen Beispiel enthält jede Liste nur ein einzelnes Plugin).

Neben der Angabe eines Plugins über seinen Namen kannst du stattdessen ein (name, options)-Tupel übergeben, wobei das zweite Element des Tupels ein Dictionary mit Optionen für das Plugin ist. Die Dokumentation der Synthesemethode sollte erklären, welche Optionen sie unterstützt. Siehe diese Liste für Links zur Dokumentation der integrierten High-Level-Synthesis-Plugins.

Nachdem du das HLSConfig-Objekt erstellt hast, übergib es als hls_config-Argument an generate_preset_pass_manager oder transpile:

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

High-Level Synthesis wird in den Stufen init, translation und optimization des gestuften Pass Managers verwendet, der von generate_preset_pass_manager zurückgegeben oder in transpile verwendet wird. Siehe Transpiler-Stufen für eine Beschreibung dieser Stufen.

Nächste Schritte​

Empfehlung