Przebiegi transpilatora oparte na AI

# 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": "--no-deps qiskit-ibm-transpiler", "qiskit_ibm_ai_local_transpiler": "--no-deps qiskit-ibm-ai-local-transpiler", "qiskit_gym": "--no-deps qiskit-gym", "twisterl": "--no-deps twisterl", "torch": "torch --index-url https://download.pytorch.org/whl/cpu", "tensorboard": "tensorboard", "gymnasium": "gymnasium", "loguru": "loguru", "safetensors": "safetensors", "backoff": "backoff", "huggingface_hub": "huggingface-hub~=0.34.4", "qiskit_qasm3_import": "qiskit-qasm3-import"}
_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")

Przebiegi transpilatora oparte na AI to przebiegi, które mogą bezpośrednio zastąpić „tradycyjne” przebiegi Qiskit w niektórych zadaniach transpilacji. Często dają lepsze wyniki niż istniejące algorytmy heurystyczne (takie jak mniejsza głębokość obwodu i liczba bramek CNOT), a jednocześnie są znacznie szybsze niż algorytmy optymalizacji, takie jak rozwiązywacze spełniania formuł boolowskich. Przebiegi transpilatora AI działają w środowisku lokalnym.

uwaga

Przebiegi transpilatora oparte na AI są w wersji beta i mogą ulec zmianom. Jeśli masz uwagi lub chcesz skontaktować się z zespołem deweloperskim, skorzystaj z tego kanału Qiskit Slack Workspace.

Aktualnie dostępne są następujące przebiegi:

Przebiegi trasowania

• AIRouting: Wybór układu i trasowanie Circuit

Przebiegi syntezy Circuit

• AICliffordSynthesis: Synteza Circuit Clifforda
• AILinearFunctionSynthesis: Synteza Circuit funkcji liniowych
• AIPermutationSynthesis: Synteza Circuit permutacji

Aby korzystać z pasów Transpilatora AI, najpierw zainstaluj pakiet qiskit-ibm-transpiler. Odwiedź dokumentację API qiskit-ibm-transpiler, aby uzyskać więcej informacji o dostępnych opcjach.

pip install qiskit-ibm-transpiler

Pas trasowania AI

Pas AIRouting pełni zarówno rolę etapu układu, jak i etapu trasowania. Można go użyć w ramach PassManager w następujący sposób:

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)

Tutaj backend określa, dla której mapy sprzężeń przeprowadzać trasowanie, optimization_level (1, 2 lub 3) określa nakład obliczeniowy przeznaczony na ten proces (wyższy poziom zazwyczaj daje lepsze wyniki, ale trwa dłużej), a layout_mode określa sposób obsługi wyboru układu. layout_mode oferuje następujące opcje:

• keep: Respektuje układ ustawiony przez poprzednie przebiegi Transpilatora (lub używa trywialnego układu, jeśli nie jest ustawiony). Zwykle używany tylko wtedy, gdy Circuit musi być uruchamiany na konkretnych Qubitach urządzenia. Często daje gorsze wyniki, ponieważ ma mniej miejsca na optymalizację.

• improve: Używa układu ustawionego przez poprzednie przebiegi Transpilatora jako punktu startowego. Jest przydatny, gdy masz dobre wstępne przypuszczenie co do układu; na przykład dla Circuit zbudowanych w sposób, który w przybliżeniu odwzorowuje mapę sprzężeń urządzenia. Jest też przydatny, gdy chcesz wypróbować inne specyficzne przebiegi układu w połączeniu z przebiegiem AIRouting.

• optimize: Jest to tryb domyślny. Działa najlepiej dla ogólnych Circuit, gdy nie masz dobrych przypuszczeń co do układu. Ten tryb ignoruje poprzednie wybory układu.

Przebiegi syntezy Circuit AI

Przebiegi syntezy Circuit AI umożliwiają optymalizację fragmentów różnych typów Circuit (Clifford, Linear Function, Permutation, Pauli Network) poprzez ich resyntetyzowanie. Typowy sposób użycia przebiegu syntezy jest następujący:

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)

Synteza respektuje mapę sprzężeń urządzenia: można ją bezpiecznie uruchomić po innych pasach trasowania bez zakłócania Circuit, dzięki czemu ogólny Circuit nadal będzie zgodny z ograniczeniami urządzenia. Domyślnie synteza zastąpi oryginalny pod-Circuit tylko wtedy, gdy zsyntetyzowany pod-Circuit jest lepszy od oryginału (obecnie sprawdzana jest tylko liczba bramek CNOT), ale można wymusić zawsze zastępowanie Circuit ustawiając replace_only_if_better=False.

Następujące przebiegi syntezy są dostępne w qiskit_ibm_transpiler.ai.synthesis:

• AICliffordSynthesis: Synteza dla Circuit Clifford (bloki bramek H, S i CX). Aktualnie obsługuje bloki do dziewięciu Qubitów.

• AILinearFunctionSynthesis: Synteza dla Circuit Linear Function (bloki bramek CX i SWAP). Aktualnie obsługuje bloki do dziewięciu Qubitów.

• AIPermutationSynthesis: Synteza dla Circuit Permutation (bloki bramek SWAP). Aktualnie dostępna dla bloków 65, 33 i 27 Qubitów.

• AIPauliNetworkSynthesis: Synteza dla Circuit sieci Pauliego (bloki bramek H, S, SX, CX, RX, RY i RZ). Aktualnie obsługuje bloki do sześciu Qubitów.

Oczekujemy stopniowego zwiększania rozmiaru obsługiwanych bloków.

Wszystkie przebiegi używają puli wątków do równoległego wysyłania kilku żądań. Domyślnie maksymalna liczba wątków to liczba rdzeni plus cztery (wartości domyślne dla obiektu Python ThreadPoolExecutor). Możesz jednak ustawić własną wartość za pomocą argumentu max_threads podczas tworzenia instancji przebiegu. Na przykład poniższa linia tworzy instancję przebiegu AILinearFunctionSynthesis, pozwalając mu używać maksymalnie 20 wątków.

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

Możesz również ustawić zmienną środowiskową AI_TRANSPILER_MAX_THREADS na żądaną maksymalną liczbę wątków, a wszystkie przebiegi syntezy tworzone po tym ustawieniu będą używać tej wartości.

Aby przebiegi syntezy AI mogły zsyntetyzować pod-Circuit, musi on leżeć na połączonym podgrafie mapy sprzężeń (jednym ze sposobów na osiągnięcie tego jest użycie przebiegu trasowania przed zebraniem bloków, ale nie jest to jedyna metoda). Przebiegi syntezy automatycznie sprawdzają, czy konkretny podgraf jest obsługiwany; jeśli nie, wyświetlone zostanie ostrzeżenie i oryginalny pod-Circuit pozostanie bez zmian.

Następujące niestandardowe przebiegi zbierające bloki dla Cliffordów, funkcji liniowych i permutacji, które można importować z qiskit_ibm_transpiler.ai.collection, uzupełniają przebiegi syntezy:

• CollectCliffords: Zbiera bloki Clifforda jako obiekty Instruction i przechowuje oryginalny pod-Circuit do porównania po syntezie.

• CollectLinearFunctions: Zbiera bloki SWAP i CX jako obiekty LinearFunction i przechowuje oryginalny pod-Circuit do porównania po syntezie.

• CollectPermutations: Zbiera bloki Circuit SWAP jako Permutations.

• CollectPauliNetworks: Zbiera bloki sieci Pauliego i przechowuje oryginalny pod-Circuit do porównania po syntezie.

Te niestandardowe przebiegi zbierające bloki ograniczają rozmiary zebranych pod-Circuit, tak aby były obsługiwane przez przebiegi syntezy zasilane przez AI. Dlatego zaleca się ich użycie po przebiegach trasowania, a przed przebiegami syntezy, w celu uzyskania lepszej ogólnej optymalizacji.

Hybrydowa transpilacja Circuit heurystyczno-AI

qiskit-ibm-transpiler umożliwia skonfigurowanie hybrydowego menedżera przebiegów, który łączy zalety heurystyki Qiskit z przebiegami Transpilatora zasilanymi przez AI. Ta funkcja działa podobnie do metody generate_pass_manager Qiskit. Typowy sposób użycia generate_ai_pass_manager jest następujący:

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)

W tym przykładzie używane są następujące opcje:

• coupling_map - Określa, której mapy sprzężeń użyć do transpilacji.
• ai_optimization_level - Określa poziom optymalizacji (1-3) stosowany dla komponentów AI PassManager.
• optimization_level - Określa, jak intensywną optymalizację przeprowadzić na obwodzie dla komponentów heurystycznych PassManager.
• ai_layout_mode - Określa, w jaki sposób część AI trasowania PassManager obsługuje układ. Zapoznaj się z sekcją przebiegu trasowania AI, aby przejrzeć opcje konfiguracji tego parametru ai_layout_mode.

Cytowanie

Cytowanie Jeśli używasz dowolnej funkcji zasilanej przez AI z pakietu qiskit-ibm-transpiler w swoich badaniach, skorzystaj z następującego zalecanego cytowania:

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