KI-gestützte Transpiler-Passes

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"qiskit": "qiskit", "qiskit_ibm_runtime": "qiskit-ibm-runtime", "qiskit_ibm_transpiler": "qiskit-ibm-transpiler"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

Die KI-gestützten Transpiler-Passes sind Passes, die als direkter Ersatz für „traditionelle“ Qiskit-Passes bei bestimmten Transpilierungsaufgaben dienen. Sie liefern oft bessere Ergebnisse als bestehende heuristische Algorithmen (z. B. geringere Tiefe und CNOT-Anzahl) und sind zugleich deutlich schneller als Optimierungsalgorithmen wie SAT-Solver. Die KI-Transpiler-Passes laufen in deiner lokalen Umgebung.

hinweis

Die KI-gestützten Transpiler-Passes befinden sich im Beta-Status und können sich noch ändern. Wenn du Feedback hast oder das Entwicklerteam kontaktieren möchtest, nutze diesen Qiskit-Slack-Workspace-Kanal.

Folgende Passes sind derzeit verfügbar:

Routing-Passes

• AIRouting: Layout-Auswahl und Circuit-Routing

Circuit-Synthese-Passes

• AICliffordSynthesis: Clifford-Circuit-Synthese
• AILinearFunctionSynthesis: Synthese linearer Funktions-Circuits
• AIPermutationSynthesis: Permutations-Circuit-Synthese

Um die KI-Transpiler-Passes zu verwenden, installiere zunächst das Paket qiskit-ibm-transpiler. In der API-Dokumentation von qiskit-ibm-transpiler findest du weitere Informationen zu den verschiedenen verfügbaren Optionen.

pip install qiskit-ibm-transpiler

KI-Routing-Pass

Der AIRouting-Pass fungiert sowohl als Layout-Stage als auch als Routing-Stage. Er kann innerhalb eines PassManager wie folgt verwendet werden:

from qiskit.transpiler import PassManager
from qiskit.circuit.library import efficient_su2
from qiskit_ibm_transpiler.ai.routing import AIRouting
from qiskit_ibm_runtime import QiskitRuntimeService
import logging

backend = QiskitRuntimeService().backend("ibm_fez")
ai_passmanager = PassManager(
    [
        AIRouting(
            backend=backend,
            optimization_level=2,
            layout_mode="optimize",
        )
    ]
)

circuit = efficient_su2(101, entanglement="circular", reps=1)
logging.getLogger(
    "qiskit_ibm_transpiler.wrappers.ai_local_synthesis"
).setLevel(logging.WARNING)
transpiled_circuit = ai_passmanager.run(circuit)

Hier legt backend fest, für welche Coupling Map geroutet wird. optimization_level (1, 2 oder 3) bestimmt den Rechenaufwand (höhere Werte liefern in der Regel bessere Ergebnisse, benötigen aber mehr Zeit), und layout_mode gibt an, wie die Layout-Auswahl gehandhabt wird. layout_mode bietet folgende Optionen:

• keep: Respektiert das Layout, das von vorherigen Transpiler-Passes gesetzt wurde (oder verwendet das triviale Layout, falls keines gesetzt wurde). Wird typischerweise nur verwendet, wenn der Circuit auf bestimmten Qubits des Geräts ausgeführt werden muss. Liefert oft schlechtere Ergebnisse, da weniger Optimierungsspielraum besteht.

• improve: Verwendet das von vorherigen Transpiler-Passes gesetzte Layout als Ausgangspunkt. Nützlich, wenn du eine gute anfängliche Schätzung für das Layout hast – zum Beispiel bei Circuits, die in etwa der Coupling Map des Geräts folgen. Hilfreich auch, wenn du andere spezifische Layout-Passes in Kombination mit dem AIRouting-Pass ausprobieren möchtest.

• optimize: Dies ist der Standardmodus. Er eignet sich am besten für allgemeine Circuits, bei denen keine guten Layout-Schätzungen vorliegen. Dieser Modus ignoriert vorherige Layout-Auswahlen.

KI-Circuit-Synthese-Passes

Die KI-Circuit-Synthese-Passes ermöglichen es dir, Teile verschiedener Circuit-Typen (Clifford, Linear Function, Permutation, Pauli Network) durch Re-Synthese zu optimieren. Eine typische Verwendung des Synthese-Passes sieht so aus:

from qiskit.transpiler import PassManager

from qiskit_ibm_transpiler.ai.routing import AIRouting
from qiskit_ibm_transpiler.ai.synthesis import AILinearFunctionSynthesis
from qiskit_ibm_transpiler.ai.collection import CollectLinearFunctions
from qiskit.circuit.library import efficient_su2

ibm_kingston = QiskitRuntimeService().backend("ibm_kingston")
ai_passmanager = PassManager(
    [
        AIRouting(
            backend=ibm_kingston,
            optimization_level=3,
            layout_mode="optimize",
            local_mode=True,
        ),  # Route circuit
        CollectLinearFunctions(),  # Collect Linear Function blocks
        AILinearFunctionSynthesis(
            backend=ibm_kingston, local_mode=True
        ),  # Re-synthesize Linear Function blocks
    ]
)

circuit = efficient_su2(10, entanglement="full", reps=1)

transpiled_circuit = ai_passmanager.run(circuit)

Die Synthese berücksichtigt die Coupling Map des Geräts: Sie kann sicher nach anderen Routing-Passes ausgeführt werden, ohne den Circuit zu beeinträchtigen, sodass der gesamte Circuit weiterhin den Gerätebeschränkungen entspricht. Standardmäßig ersetzt die Synthese den ursprünglichen Sub-Circuit nur, wenn der synthetisierte Sub-Circuit eine Verbesserung darstellt (derzeit wird nur die CNOT-Anzahl geprüft). Durch Setzen von replace_only_if_better=False kann die Ersetzung jedoch immer erzwungen werden.

Folgende Synthese-Passes sind aus qiskit_ibm_transpiler.ai.synthesis verfügbar:

• AICliffordSynthesis: Synthese für Clifford-Circuits (Blöcke aus H-, S- und CX-Gates). Derzeit Blöcke mit bis zu neun Qubits.

• AILinearFunctionSynthesis: Synthese für Linear Function-Circuits (Blöcke aus CX- und SWAP-Gates). Derzeit Blöcke mit bis zu neun Qubits.

• AIPermutationSynthesis: Synthese für Permutation-Circuits (Blöcke aus SWAP-Gates). Derzeit verfügbar für 65-, 33- und 27-Qubit-Blöcke.

• AIPauliNetworkSynthesis: Synthese für Pauli-Network-Circuits (Blöcke aus H-, S-, SX-, CX-, RX-, RY- und RZ-Gates). Derzeit Blöcke mit bis zu sechs Qubits.

Wir planen, die unterstützte Blockgröße schrittweise zu erhöhen.

Alle Passes verwenden einen Thread-Pool, um mehrere Anfragen parallel zu senden. Standardmäßig entspricht die maximale Thread-Anzahl der Anzahl der Kerne plus vier (Standardwerte des Python-Objekts ThreadPoolExecutor). Du kannst jedoch beim Instanziieren des Passes über das Argument max_threads einen eigenen Wert festlegen. Die folgende Zeile instanziiert beispielsweise den AILinearFunctionSynthesis-Pass und erlaubt ihm, maximal 20 Threads zu verwenden.

AILinearFunctionSynthesis(backend=ibm_torino, max_threads=20)  # Re-synthesize Linear Function blocks using 20 threads max

Du kannst auch die Umgebungsvariable AI_TRANSPILER_MAX_THREADS auf die gewünschte maximale Thread-Anzahl setzen – alle danach instanziierten Synthese-Passes verwenden dann diesen Wert.

Damit die KI-Synthese-Passes einen Sub-Circuit synthetisieren können, muss dieser auf einem zusammenhängenden Teilgraphen der Coupling Map liegen (eine Möglichkeit dafür ist ein Routing-Pass vor dem Sammeln der Blöcke, aber das ist nicht der einzige Weg). Die Synthese-Passes prüfen automatisch, ob der spezifische Teilgraph unterstützt wird. Falls nicht, wird eine Warnung ausgegeben und der ursprüngliche Sub-Circuit bleibt unverändert.

Die folgenden benutzerdefinierten Collection-Passes für Cliffords, lineare Funktionen und Permutationen, die aus qiskit_ibm_transpiler.ai.collection importiert werden können, ergänzen die Synthese-Passes:

• CollectCliffords: Sammelt Clifford-Blöcke als Instruction-Objekte und speichert den ursprünglichen Sub-Circuit zum späteren Vergleich nach der Synthese.

• CollectLinearFunctions: Sammelt Blöcke aus SWAP- und CX-Gates als LinearFunction-Objekte und speichert den ursprünglichen Sub-Circuit zum späteren Vergleich nach der Synthese.

• CollectPermutations: Sammelt Blöcke aus SWAP-Circuits als Permutations.

• CollectPauliNetworks: Sammelt Pauli-Network-Blöcke und speichert den ursprünglichen Sub-Circuit zum späteren Vergleich nach der Synthese.

Diese benutzerdefinierten Collection-Passes begrenzen die Größe der gesammelten Sub-Circuits, sodass diese von den KI-gestützten Synthese-Passes unterstützt werden. Es wird daher empfohlen, sie nach den Routing-Passes und vor den Synthese-Passes einzusetzen, um eine bessere Gesamtoptimierung zu erzielen.

Hybride Circuit-Transpilierung aus Heuristik und KI

qiskit-ibm-transpiler ermöglicht es dir, einen hybriden Pass Manager zu konfigurieren, der die Stärken von Qiskits Heuristik und den KI-gestützten Transpiler-Passes kombiniert. Dieses Feature verhält sich ähnlich wie die Qiskit-Methode generate_pass_manager. Eine typische Verwendung von generate_ai_pass_manager sieht so aus:

from qiskit_ibm_transpiler import generate_ai_pass_manager
from qiskit.circuit.library import efficient_su2
from qiskit_ibm_runtime import QiskitRuntimeService

backend = QiskitRuntimeService().backend("ibm_kingston")
kingston_coupling_map = backend.coupling_map

su2_circuit = efficient_su2(101, entanglement="circular", reps=1)

ai_transpiler_pass_manager = generate_ai_pass_manager(
    coupling_map=kingston_coupling_map,
    ai_optimization_level=3,
    optimization_level=3,
    ai_layout_mode="optimize",
)

ai_su2_transpiled_circuit = ai_transpiler_pass_manager.run(su2_circuit)

Die folgenden Optionen werden in diesem Beispiel verwendet:

• coupling_map - Gibt an, welche Coupling Map für die Transpilation verwendet werden soll.
• ai_optimization_level - Gibt das Optimierungslevel (1-3) an, das für die KI-Komponenten des PassManager verwendet wird.
• optimization_level - Gibt an, wie viel Optimierung am Circuit für die heuristischen Komponenten des PassManager durchgeführt werden soll.
• ai_layout_mode - Gibt an, wie der KI-Routing-Teil des PassManager das Layout handhabt. Im Abschnitt KI-Routing-Pass findest du die Konfigurationsoptionen für diesen ai_layout_mode-Parameter.

Zitierung

Zitierung Wenn du KI-gestützte Funktionen aus dem Paket qiskit-ibm-transpiler in deiner Forschung nutzt, zitiere bitte wie folgt:

@misc{2405.13196,
Author = {David Kremer and Victor Villar and Hanhee Paik and Ivan Duran and Ismael Faro and Juan Cruz-Benito},
Title = {Practical and efficient quantum circuit synthesis and transpiling with Reinforcement Learning},
Year = {2024},
Eprint = {arXiv:2405.13196},
}