KI-gestützte Transpiler-Pass

Die KI-gestützten Transpiler-Passes sind Passes, die bei bestimmten Transpiling-Aufgaben als direkter Ersatz für „herkömmliche“ Qiskit-Passes dienen. Sie liefern oft bessere Ergebnisse als bestehende heuristische Algorithmen (z. B. geringere Suchbreite und CNOT-Zahl), sind aber auch wesentlich schneller als Optimierungsalgorithmen wie Solver für die Boolesche Erfüllbarkeit. Der KI-Transpiler führt die Durchläufe in Ihrer lokalen Umgebung aus.

Die folgenden Ausweise sind derzeit erhältlich:

Routing-Pässe

• AIRouting: Auswahl des Layouts und Entflechtung der Schaltkreise

Die Schaltungssynthese läuft

• AICliffordSynthesis: Synthese von Clifford-Schaltungen
• AILinearFunctionSynthesis: Synthese von Schaltkreisen mit linearer Funktion
• AIPermutationSynthesis: Synthese von Permutationsschaltungen

Um die AI-Transpiler-Pässe zu verwenden, installieren Sie zunächst das qiskit-ibm-transpiler Paket. Weitere Informationen zu den verschiedenen verfügbaren Optionen finden Sie in der API-Dokumentation zu qiskit-ibm-transpiler.

pip install qiskit-ibm-transpiler

KI-Routing-Pass

Der Pass AIRouting dient sowohl als Layout- als auch als Routing-Stufe. Sie kann innerhalb einer 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 bestimmt backend , für welche Kopplungskarte geroutet werden soll, optimization_level (1, 2 oder 3) bestimmt den Rechenaufwand, der für den Prozess aufgewendet werden soll (ein höherer Wert führt in der Regel zu besseren Ergebnissen, dauert aber länger), und layout_mode gibt an, wie die Layout-Auswahl behandelt werden soll. Die Website layout_mode bietet die folgenden Optionen:

• keep: Dies respektiert das Layout, das durch die vorherigen Transpiler-Durchläufe festgelegt wurde (oder verwendet das triviale Layout, wenn es nicht festgelegt wurde). Sie wird in der Regel nur verwendet, wenn die Schaltung auf bestimmten Qubits des Geräts ausgeführt werden muss. Sie führt oft zu schlechteren Ergebnissen, weil sie weniger Spielraum für Optimierungen hat.
• improve: Dabei wird das durch die vorangegangenen Transpilerdurchläufe festgelegte Layout als Ausgangspunkt verwendet. Sie ist nützlich, wenn Sie eine gute Vorstellung vom Layout haben, z. B. bei Schaltungen, die so aufgebaut sind, dass sie ungefähr der Kopplungskarte des Geräts entsprechen. Es ist auch nützlich, wenn Sie andere spezifische Layout-Durchgänge in Kombination mit dem AIRouting -Durchgang ausprobieren möchten.
• optimize: Dies ist der Standardmodus. Sie eignet sich am besten für allgemeine Schaltungen, bei denen man das Layout nicht gut einschätzen kann. In diesem Modus werden vorherige Layout-Auswahlen ignoriert.

AI-Schaltungssynthese passiert

Die KI-Schaltungssynthese ermöglicht es Ihnen, Teile verschiedener Schaltungstypen (Clifford, Lineare Funktion, Permutation, Pauli-Netzwerk) zu optimieren, indem Sie sie neu synthetisieren. Ein typischer Weg, den Synthesedurchlauf zu verwenden, ist der folgende:

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 respektiert die Kopplungskarte des Geräts: Sie kann sicher nach anderen Routing-Durchläufen ausgeführt werden, ohne die Schaltung zu stören, so dass die Gesamtschaltung immer noch den Beschränkungen des Geräts folgt. Standardmäßig wird die Synthese die ursprüngliche Teilschaltung nur dann ersetzen, wenn die synthetisierte Teilschaltung die ursprüngliche verbessert (derzeit wird nur die CNOT-Anzahl überprüft), aber dies kann erzwungen werden, um die Schaltung immer zu ersetzen, indem replace_only_if_better=False gesetzt wird.

Die folgenden Synthesepässe sind unter qiskit_ibm_transpiler.ai.synthesis erhältlich:

• AICliffordSynthese : Synthese für Clifford-Schaltungen (Blöcke aus H, S und CX Gattern). Derzeit bis zu neun Qubit-Blöcke.
• AILinearFunctionSynthesis : Synthese für lineare Funktionsschaltungen (Blöcke aus CX und SWAP Gattern). Derzeit bis zu neun Qubit-Blöcke.
• AIPermutationSynthese : Synthese für Permutationsschaltungen (Blöcke von SWAP Gattern). Derzeit verfügbar für 65-, 33- und 27-Qubit-Blöcke.
• AIPauliNetworkSynthesis : Synthese für Pauli-Netzwerk-Schaltungen (Blöcke aus H, S, SX, CX, RX, RY und RZ Gattern). Derzeit bis zu sechs Qubit-Blöcke.

Wir gehen davon aus, dass wir die Größe der unterstützten Blöcke schrittweise erhöhen werden.

Alle Durchläufe verwenden einen Thread-Pool, um mehrere Anfragen parallel zu senden. Standardmäßig entspricht die Anzahl der maximalen Threads der Anzahl der Kerne plus vier (Standardwerte für das Objekt ThreadPoolExecutor Python ). Sie können jedoch einen eigenen Wert mit dem Argument max_threads bei der Instanziierung des Passes festlegen. Die folgende Zeile instanziiert zum Beispiel den Pass AILinearFunctionSynthesis , der maximal 20 Threads verwenden kann.

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

Sie können auch die Umgebungsvariable AI_TRANSPILER_MAX_THREADS auf die gewünschte Anzahl der maximalen Threads setzen, und alle danach instanziierten Synthesedurchläufe werden diesen Wert verwenden.

Damit die KI-Synthesepässe eine Teilschaltung synthetisieren können, muss sie auf einem zusammenhängenden Teilgraphen der Kopplungskarte liegen (eine Möglichkeit, dies zu erreichen, ist ein Routing-Pass vor dem Sammeln der Blöcke, aber dies ist nicht die einzige Möglichkeit). Die Synthesedurchläufe prüfen automatisch, ob der spezifische Teilgraph unterstützt wird. Ist dies nicht der Fall, wird eine Warnung ausgegeben und der ursprüngliche Teilschaltkreis bleibt unverändert.

Die folgenden benutzerdefinierten Sammelpässe für Cliffords, lineare Funktionen und Permutationen, die von qiskit_ibm_transpiler.ai.collection importiert werden können, ergänzen die Synthesepässe:

• SammelnCliffords : Sammelt Clifford-Blöcke als Instruction Objekte und speichert die ursprüngliche Teilschaltung, um sie nach der Synthese mit ihr zu vergleichen.
• SammleLineareFunktionen : Sammelt Blöcke von SWAP und CX als LinearFunction Objekte und speichert die ursprüngliche Teilschaltung, um sie nach der Synthese mit ihr zu vergleichen.
• CollectPermutations : Sammelt Blöcke von SWAP Schaltungen als Permutations.
• SammelnPauliNetzwerke : Sammelt Pauli-Netz-Blöcke und speichert die ursprüngliche Teilschaltung, um sie nach der Synthese mit ihr zu vergleichen.

Diese benutzerdefinierten Sammelpässe begrenzen die Größe der gesammelten Teilschaltungen, so dass sie von den KI-gesteuerten Synthesepässen unterstützt werden. Es wird daher empfohlen, sie nach den Routing-Durchläufen und vor den Synthese-Durchläufen zu verwenden, um eine bessere Gesamtoptimierung zu erreichen.

Hybride heuristische KI-Schaltungstranspilierung

Unter qiskit-ibm-transpiler können Sie einen hybriden Passmanager konfigurieren, der das Beste aus der Heuristik von Qiskit und den KI-gesteuerten Transpiler-Pässen kombiniert. Diese Funktion verhält sich ähnlich wie die Methode von Qiskit generate_pass_manager . Ein typischer Weg, generate_ai_pass_manager zu verwenden, ist der folgende:

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 Kopplungskarte für die Transpilierung verwendet werden soll.
• ai_optimization_level - Gibt die Optimierungsstufe (1-3) an, die für die AI-Komponenten des PassManager verwendet werden soll.
• optimization_level - Gibt an, wie stark die Schaltung für die heuristischen Komponenten der PassManager optimiert werden soll.
• ai_layout_mode - Gibt an, wie der AI-Routing-Teil von PassManager das Layout behandelt. Die Konfigurationsmöglichkeiten für diesen Parameter ai_layout_mode finden Sie im Abschnitt AI Routing Pass.

Quelle

Quellenangabe Wenn Sie in Ihrer Forschungsarbeit eine der KI-gestützten Funktionen aus dem qiskit-ibm-transpiler Paket verwenden, geben Sie bitte die folgende empfohlene Quellenangabe an:

@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},
}