Wprowadzenie do usługi transpilacji Qiskit opartej na AI

Szacowane użycie QPU: brak (UWAGA: Ten samouczek nie wykonuje zadań, ponieważ skupia się na transpilacji)

Tło

Usługa transpilacji Qiskit oparta na AI (QTS) wprowadza optymalizacje oparte na uczeniu maszynowym zarówno w przebiegach routingu, jak i syntezy. Tryby AI zostały zaprojektowane, aby przezwyciężyć ograniczenia tradycyjnej transpilacji — szczególnie w przypadku układów na dużą skalę i złożonych topologii sprzętu.

Od lipca 2025 r. Usługa Transpilacji została przeniesiona na nową platformę IBM Quantum® i nie jest już dostępna. Najnowsze informacje o statusie Usługi Transpilacji znajdziesz w dokumentacji usługi transpilacji. Możesz nadal korzystać z transpilera AI lokalnie, podobnie jak ze standardowej transpilacji Qiskit. Wystarczy zastąpić generate_preset_pass_manager() funkcją generate_ai_pass_manager(). Funkcja ta tworzy menedżer przebiegów integrujący przejścia routingu i syntezy oparte na AI bezpośrednio w lokalnym przepływie pracy transpilacji.

Kluczowe funkcje przebiegów AI

• Przebiegi routingu: Routing oparty na AI może dynamicznie dostosowywać ścieżki qubitów w zależności od konkretnego układu i backendu, redukując potrzebę stosowania nadmiernej liczby bramek SWAP.

  • AIRouting: Wybór rozmieszczenia i routing układu

• Przebiegi syntezy: Techniki AI optymalizują rozkład bramek wieloqubitowych, minimalizując liczbę bramek dwuqubitowych, które są zazwyczaj bardziej podatne na błędy.

  • AICliffordSynthesis: Synteza bramek Clifforda
  • AILinearFunctionSynthesis: Synteza układów funkcji liniowych
  • AIPermutationSynthesis: Synteza układów permutacji
  • AIPauliNetworkSynthesis: Synteza sieci Pauliego (dostępna tylko w usłudze Qiskit Transpiler Service, nie w środowisku lokalnym)

• Porównanie z tradycyjną transpilacją: Standardowy transpiler Qiskit to solidne narzędzie zdolne efektywnie obsługiwać szeroki zakres układów kwantowych. Jednak gdy układy stają się większe lub konfiguracje sprzętowe bardziej złożone, przebiegi AI mogą przynosić dodatkowe zyski optymalizacyjne. Dzięki wykorzystaniu uczonych modeli do routingu i syntezy QTS dodatkowo udoskonala rozmieszczenia układów i zmniejsza narzut dla trudnych lub wielkoskalowych zadań kwantowych.

Ten samouczek ocenia tryby AI, korzystając z przebiegów routingu i syntezy, porównując wyniki z tradycyjną transpilacją, aby pokazać, gdzie AI oferuje przewagę wydajnościową.

Więcej informacji o dostępnych przebiegach AI znajdziesz w dokumentacji przebiegów AI.

Dlaczego warto używać AI do transpilacji układów kwantowych?

W miarę jak układy kwantowe rosną pod względem rozmiaru i złożoności, tradycyjne metody transpilacji mają trudności z efektywną optymalizacją rozmieszczenia i redukcją liczby bramek. Większe układy, szczególnie te obejmujące setki qubitów, stwarzają poważne wyzwania dla routingu i syntezy ze względu na ograniczenia urządzeń, ograniczoną łączność i współczynniki błędów qubitów.

Właśnie tutaj transpilacja oparta na AI oferuje potencjalne rozwiązanie. Wykorzystując techniki uczenia maszynowego, transpiler oparty na AI w Qiskit może podejmować mądrzejsze decyzje dotyczące routingu qubitów i syntezy bramek, prowadząc do lepszej optymalizacji wielkoskalowych układów kwantowych.

Krótkie wyniki benchmarkingu

W testach benchmarkingowych transpiler AI konsekwentnie generował płytsze, wyższej jakości układy w porównaniu ze standardowym transpilerem Qiskit. W tych testach użyliśmy domyślnej strategii menedżera przebiegów Qiskit skonfigurowanej za pomocą [generate_preset_passmanager]. Choć ta domyślna strategia jest często skuteczna, może sobie nie radzić z większymi lub bardziej złożonymi układami. Natomiast przebiegi oparte na AI osiągnęły średnio 24% redukcję liczby bramek dwuqubitowych i 36% redukcję głębokości układu dla dużych układów (ponad 100 qubitów) podczas transpilacji do topologii heavy-hex sprzętu IBM Quantum. Więcej informacji na temat tych benchmarków znajdziesz w tym blogu.

Ten samouczek bada kluczowe zalety przebiegów AI i to, jak wypadają one w porównaniu z tradycyjnymi metodami.

# Added by doQumentation — required packages for this notebook
!pip install -q matplotlib numpy pandas qiskit qiskit-ibm-runtime qiskit-ibm-transpiler

# This cell is hidden from users;
# it just disables a linting rule.
# ruff: noqa: F811

Wymagania

Przed rozpoczęciem tego samouczka upewnij się, że masz zainstalowane:

• Qiskit SDK v1.0 lub nowszy, z obsługą wizualizacji
• Qiskit Runtime (pip install qiskit-ibm-runtime) v0.22 lub nowszy
• Qiskit IBM® Transpiler z lokalnym trybem AI (pip install 'qiskit-ibm-transpiler[ai-local-mode]')

Konfiguracja

from qiskit import QuantumCircuit
from qiskit.circuit.library import efficient_su2, PermutationGate
from qiskit.synthesis.qft import synth_qft_full
from qiskit.circuit.random import random_circuit, random_clifford_circuit
from qiskit.transpiler import generate_preset_pass_manager, CouplingMap
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit_ibm_transpiler import generate_ai_pass_manager
from qiskit.synthesis.permutation import (
    synth_permutation_depth_lnn_kms,
    synth_permutation_basic,
)
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
import time
import logging

seed = 42

# Used for generating permutation circuits in part two for comparison
def generate_permutation_circuit(width, pattern):
    circuit = QuantumCircuit(width)
    circuit.append(
        PermutationGate(pattern=pattern),
        qargs=range(width),
    )
    return circuit

# Creates a Bernstein-Vazirani circuit given the number of qubits
def create_bv_circuit(num_qubits):
    qc = QuantumCircuit(num_qubits, num_qubits - 1)
    qc.x(num_qubits - 1)
    qc.h(qc.qubits)
    for i in range(num_qubits - 1):
        qc.cx(i, num_qubits - 1)
    qc.h(qc.qubits[:-1])
    return qc

# Transpile a circuit with a given pass manager and return metrics
def transpile_with_metrics(pass_manager, circuit):
    start = time.time()
    qc_out = pass_manager.run(circuit)
    elapsed = time.time() - start

    depth_2q = qc_out.depth(lambda x: x.operation.num_qubits == 2)
    gate_count = qc_out.size()

    return qc_out, {
        "depth_2q": depth_2q,
        "gate_count": gate_count,
        "time_s": elapsed,
    }

# Used for collecting metrics for part 3 of synthesis methods
def synth_transpile_with_metrics(qc, pm, pattern_id, method):
    start = time.time()
    qc = pm.run(qc)
    elapsed = time.time() - start

    return {
        "Pattern": pattern_id,
        "Method": method,
        "Depth (2Q)": qc.depth(lambda x: x.operation.num_qubits == 2),
        "Gates": qc.size(),
        "Time (s)": elapsed,
    }

# Ignore logs like "INFO:qiskit_ibm_transpiler.wrappers.ai_local_synthesis:Running Linear Functions AI synthesis on local mode"

logging.getLogger(
    "qiskit_ibm_transpiler.wrappers.ai_local_synthesis"
).setLevel(logging.WARNING)

Część I. Wzorce Qiskit

Zobaczmy teraz, jak używać usługi transpilacji AI z prostym układem kwantowym, korzystając ze wzorców Qiskit. Kluczem jest stworzenie PassManager za pomocą generate_ai_pass_manager() zamiast standardowego generate_preset_pass_manager().

Krok 1: Odwzorowanie klasycznych danych wejściowych na problem kwantowy

W tej sekcji przetestujemy transpiler AI na układzie efficient_su2, szeroko stosowanym ansatz dostosowanym do sprzętu. Układ ten jest szczególnie przydatny w wariantowych algorytmach kwantowych (np. VQE) i zadaniach kwantowego uczenia maszynowego, co czyni go idealnym przypadkiem testowym do oceny wydajności transpilacji.

Układ efficient_su2 składa się z naprzemiennych warstw jednobitowych rotacji i bramek splątujących, takich jak CNOT. Warstwy te umożliwiają elastyczne eksplorowanie przestrzeni stanów kwantowych przy jednoczesnym zachowaniu zarządzalnej głębokości bramek. Optymalizując ten układ, dążymy do redukcji liczby bramek, poprawy wierności i minimalizacji szumów. To sprawia, że jest on silnym kandydatem do testowania wydajności transpilatora AI.

# For our transpilation, we will use a large circuit of 101 qubits
qc = efficient_su2(90, entanglement="circular", reps=1).decompose()

# Draw a smaller version of the circuit to get a visual representation
qc_small = efficient_su2(5, entanglement="circular", reps=1).decompose()
qc_small.draw(output="mpl")

Krok 2: Optymalizacja problemu do wykonania na sprzęcie kwantowym

Wybór backendu

W tym przykładzie wybieramy najmniej obciążony, działający backend IBM Quantum, który nie jest symulatorem i ma co najmniej 100 qubitów:

Uwaga: Ponieważ najmniej obciążony backend może się zmieniać w czasie, różne urządzenia mogą być wybierane przy różnych uruchomieniach. Właściwości specyficzne dla urządzenia, takie jak mapy sprzężeń, mogą prowadzić do różnic w transponowanych układach.

service = QiskitRuntimeService()
backend = service.least_busy(
    operational=True, simulator=False, min_num_qubits=100
)
cm = backend.coupling_map
print(f"Using backend: {backend.name}")

Using backend: ibm_torino

Tworzenie menedżerów przebiegów AI i tradycyjnego

Aby ocenić skuteczność transpilatora AI, przeprowadzimy dwa przebiegi transpilacji. Najpierw transpilujemy układ za pomocą transpilatora AI. Następnie porównamy wyniki, transpilując ten sam układ bez transpilatora AI, używając tradycyjnych metod. Oba procesy transpilacji będą korzystać z tej samej mapy sprzężeń z wybranego backendu, a poziom optymalizacji zostanie ustawiony na 3 dla zachowania uczciwego porównania.

Obie metody odzwierciedlają standardowe podejście do tworzenia instancji PassManager do transpilacji układów w Qiskit.

pm_ai = generate_ai_pass_manager(
    optimization_level=3,
    ai_optimization_level=3,
    coupling_map=cm,
    include_ai_synthesis=True,  # used for part 3 when comparing synthesis methods
)

pm_no_ai = generate_preset_pass_manager(
    optimization_level=3,
    coupling_map=cm,
    seed_transpiler=seed,  # note that the AI pass manager does not currently support seeding
)

Transpiluj układy i rejestruj czasy.

# Transpile using standard (non-AI) pass manager
_, metrics_no_ai = transpile_with_metrics(pm_no_ai, qc)
print(
    f"Standard transpilation: Depth (2q) {metrics_no_ai['depth_2q']}, "
    f"Gate count {metrics_no_ai['gate_count']}, Time {metrics_no_ai['time_s']}"
)

# Transpile using AI pass manager
_, metrics_ai = transpile_with_metrics(pm_ai, qc)
print(
    f"AI transpilation      : Depth (2q) {metrics_ai['depth_2q']}, "
    f"Gate count {metrics_ai['gate_count']}, Time {metrics_ai['time_s']}"
)

Standard transpilation: Depth (2q) 95, Gate count 458, Time 0.04650712013244629
AI transpilation      : Depth (2q) 90, Gate count 456, Time 0.9342479705810547

W tym teście porównujemy wydajność transpilatora AI i standardowej metody transpilacji na układzie efficient_su2. Transpiler AI osiąga zauważalnie płytszą głębokość układu przy podobnej liczbie bramek.

• Głębokość układu: Transpiler AI generuje układ o mniejszej głębokości dwuqubitowej. Jest to spodziewane, ponieważ przebiegi AI są wytrenowane do optymalizacji głębokości poprzez uczenie się wzorców interakcji qubitów i bardziej efektywne wykorzystywanie łączności sprzętowej niż heurystyki oparte na regułach.

• Liczba bramek: Całkowita liczba bramek pozostaje podobna w obu metodach. Jest to zgodne z oczekiwaniami, ponieważ standardowa transpilacja oparta na SABRE jawnie minimalizuje liczbę swapów, która dominuje w narzucie bramkowym. Transpiler AI natomiast priorytetyzuje ogólną głębokość i może czasami wymienić kilka dodatkowych bramek na krótszą ścieżkę wykonania.

• Czas transpilacji: Transpiler AI działa dłużej niż metoda standardowa. Wynika to z dodatkowego kosztu obliczeniowego związanego z wywoływaniem uczonych modeli podczas routingu i syntezy. Natomiast transpiler oparty na SABRE jest teraz znacznie szybszy po przepisaniu i zoptymalizowaniu w Rust, zapewniając wysoce efektywny heurystyczny routing w skali.

Ważne jest, aby zauważyć, że wyniki te dotyczą tylko jednego układu. Aby uzyskać pełne zrozumienie, jak transpiler AI wypada w porównaniu z tradycyjnymi metodami, konieczne jest przetestowanie różnorodnych układów. Wydajność QTS może się znacznie różnić w zależności od rodzaju optymalizowanego układu. Aby uzyskać szersze porównanie, zajrzyj do powyższych benchmarków lub odwiedź blog.

Krok 3: Wykonanie za pomocą prymitywów Qiskit

Ponieważ ten samouczek skupia się na transpilacji, żadne eksperymenty nie będą wykonywane na urządzeniu kwantowym. Celem jest wykorzystanie optymalizacji z Kroku 2 w celu uzyskania transpilowanego układu o zredukowanej głębokości lub liczbie bramek.

Krok 4: Postprzetwarzanie i zwrócenie wyniku w pożądanym formacie klasycznym

Ponieważ w tym notatniku nie ma wykonania, nie ma wyników do postprzetworzenia.

Część II. Analiza i benchmarking transpilowanych układów

W tej sekcji pokażemy, jak szczegółowo analizować transpilowany układ i porównywać go z oryginalną wersją. Skupimy się na metrykach takich jak głębokość układu, liczba bramek i czas transpilacji, aby ocenić skuteczność optymalizacji. Ponadto omówimy, jak wyniki mogą się różnić w zależności od różnych typów układów, oferując wgląd w szerszą wydajność transpilatora w różnych scenariuszach.

# Circuits to benchmark
seed = 42
circuits = [
    {
        "name": "Random",
        "qc": random_circuit(num_qubits=30, depth=10, seed=seed),
    },
    {
        "name": "Clifford",
        "qc": random_clifford_circuit(
            num_qubits=40, num_gates=200, seed=seed
        ),
    },
    {
        "name": "QFT",
        "qc": synth_qft_full(num_qubits=20, do_swaps=False).decompose(),
    },
    {
        "name": "BV",
        "qc": create_bv_circuit(40),
    },
]

results = []

# Run the transpilation for each circuit and store the results
for circuit in circuits:
    qc_no_ai, metrics_no_ai = transpile_with_metrics(pm_no_ai, circuit["qc"])
    qc_ai, metrics_ai = transpile_with_metrics(pm_ai, circuit["qc"])

    print("Completed transpilation for", circuit["name"])

    results.append(
        {
            "Circuit": circuit["name"],
            "Depth 2Q (No AI)": metrics_no_ai["depth_2q"],
            "Gate Count (No AI)": metrics_no_ai["gate_count"],
            "Time (No AI)": metrics_no_ai["time_s"],
            "Depth 2Q (AI)": metrics_ai["depth_2q"],
            "Gate Count (AI)": metrics_ai["gate_count"],
            "Time (AI)": metrics_ai["time_s"],
        }
    )

df = pd.DataFrame(results)
df

Completed transpilation for Random
Completed transpilation for Clifford
Completed transpilation for QFT
Completed transpilation for BV

Circuit  Depth 2Q (No AI)  Gate Count (No AI)  Time (No AI)  \
0    Random                37                 221      0.039347
1  Clifford                36                 232      0.036633
2       QFT               165                 924      0.077458
3        BV                65                 155      0.024993

   Depth 2Q (AI)  Gate Count (AI)  Time (AI)
0             24              181   0.773718
1             43              267   1.097431
2            130              913   3.660771
3             70              155   0.345522

Średnia procentowa redukcja dla każdej metryki. Wartości dodatnie oznaczają poprawę, ujemne — pogorszenie.

# Average reduction from non-AI to AI transpilation as a percentage
avg_reduction_depth = (
    (df["Depth 2Q (No AI)"] - df["Depth 2Q (AI)"]).mean()
    / df["Depth 2Q (No AI)"].mean()
    * 100
)
avg_reduction_gates = (
    (df["Gate Count (No AI)"] - df["Gate Count (AI)"]).mean()
    / df["Gate Count (No AI)"].mean()
    * 100
)
avg_reduction_time = (
    (df["Time (No AI)"] - df["Time (AI)"]).mean()
    / df["Time (No AI)"].mean()
    * 100
)

print(f"Average reduction in depth: {avg_reduction_depth:.2f}%")
print(f"Average reduction in gate count: {avg_reduction_gates:.2f}%")
print(f"Average reduction in transpilation time: {avg_reduction_time:.2f}%")

Average reduction in depth: 11.88%
Average reduction in gate count: 1.04%
Average reduction in transpilation time: -3193.95%

fig, axs = plt.subplots(1, 3, figsize=(21, 6))
df.plot(
    x="Circuit",
    y=["Depth 2Q (No AI)", "Depth 2Q (AI)"],
    kind="bar",
    ax=axs[0],
)
axs[0].set_title("Circuit Depth Comparison")
axs[0].set_ylabel("Depth")
axs[0].set_xlabel("Circuit")
axs[0].tick_params(axis="x", rotation=45)
df.plot(
    x="Circuit",
    y=["Gate Count (No AI)", "Gate Count (AI)"],
    kind="bar",
    ax=axs[1],
)
axs[1].set_title("Gate Count Comparison")
axs[1].set_ylabel("Gate Count")
axs[1].set_xlabel("Circuit")
axs[1].tick_params(axis="x", rotation=45)
df.plot(x="Circuit", y=["Time (No AI)", "Time (AI)"], kind="bar", ax=axs[2])
axs[2].set_title("Time Comparison")
axs[2].set_ylabel("Time (seconds)")
axs[2].set_xlabel("Circuit")
axs[2].tick_params(axis="x", rotation=45)
fig.suptitle(
    "Benchmarking AI transpilation vs Non-AI transpilation for various circuits"
)

plt.tight_layout()
plt.show()

Wydajność transpilatora AI znacznie się różni w zależności od rodzaju optymalizowanego układu. W niektórych przypadkach osiąga on znaczące redukcje głębokości układu i liczby bramek w porównaniu ze standardowym transpilerem. Jednak ulepszenia te często wiążą się z istotnym wzrostem czasu wykonania.

W przypadku niektórych typów układów transpiler AI może dawać nieco lepsze wyniki pod względem głębokości układu, ale może też prowadzić do wzrostu liczby bramek i znacznej kary za czas wykonania. Obserwacje te sugerują, że korzyści z transpilatora AI nie są jednolite dla wszystkich typów układów. Zamiast tego jego skuteczność zależy od konkretnych cech układu, co sprawia, że bardziej nadaje się on do jednych zastosowań niż do innych.

Kiedy użytkownik powinien wybrać transpilację opartą na AI?

Transpiler oparty na AI w Qiskit sprawdza się w scenariuszach, gdzie tradycyjne metody transpilacji mają trudności — szczególnie w przypadku wielkoskalowych i złożonych układów kwantowych. Dla układów obejmujących setki qubitów lub skierowanych na sprzęt o skomplikowanych mapach sprzężeń transpiler AI oferuje lepszą optymalizację pod względem głębokości układu, liczby bramek i wydajności czasu wykonania. W testach benchmarkingowych konsekwentnie przewyższał tradycyjne metody, generując znacznie płytsze układy i zmniejszając liczbę bramek — co jest kluczowe dla poprawy wydajności i łagodzenia szumów na rzeczywistym sprzęcie kwantowym.

Użytkownicy powinni rozważyć transpilację opartą na AI, gdy pracują z:

• Dużymi układami, gdzie tradycyjne metody nie radzą sobie efektywnie ze skalą.
• Złożonymi topologiami sprzętowymi, gdzie pojawiają się wyzwania związane z łącznością urządzenia i routingiem.
• Aplikacjami wrażliwymi na wydajność, gdzie redukcja głębokości układu i poprawa wierności są kluczowe.

Część III. Eksploracja syntezy sieci permutacji opartej na AI

Sieci permutacji są fundamentalne w obliczeniach kwantowych, szczególnie dla systemów ograniczonych przez topologie z ograniczoną łącznością. Sieci te ułatwiają interakcje długodystansowe poprzez dynamiczne zamienianie qubitów w celu naśladowania łączności każdy-z-każdym na sprzęcie z ograniczoną łącznością. Takie transformacje są niezbędne do implementowania złożonych algorytmów kwantowych na urządzeniach bliskiej przyszłości, gdzie interakcje często wykraczają poza najbliższych sąsiadów.

W tej sekcji podkreślamy syntezę sieci permutacji jako przekonujący przypadek użycia transpilatora opartego na AI w Qiskit. W szczególności przebieg AIPermutationSynthesis wykorzystuje optymalizację opartą na AI do generowania wydajnych układów dla zadań permutacji qubitów. Natomiast ogólne podejścia do syntezy często mają trudności z balansowaniem liczby bramek i głębokości układu, zwłaszcza w scenariuszach z gęstymi interakcjami qubitów lub przy próbach osiągnięcia pełnej łączności.

Przeprowadzimy przykład wzorców Qiskit demonstrujący syntezę sieci permutacji w celu osiągnięcia łączności każdy-z-każdym dla zestawu qubitów. Porównamy wydajność AIPermutationSynthesis ze standardowymi metodami syntezy w Qiskit. Ten przykład pokaże, jak transpiler AI optymalizuje pod kątem mniejszej głębokości układu i liczby bramek, podkreślając jego zalety w praktycznych przepływach pracy kwantowej. Aby aktywować przebieg syntezy AI, użyjemy funkcji generate_ai_pass_manager() z parametrem include_ai_synthesis ustawionym na True.

Krok 1: Odwzorowanie klasycznych danych wejściowych na problem kwantowy

Aby przedstawić klasyczny problem permutacji na komputerze kwantowym, zaczynamy od zdefiniowania struktury obwodów kwantowych. W tym przykładzie:

1. Inicjalizacja Circuit kwantowego: Przydzielamy 27 Qubitów, aby dopasować się do używanego backendu, który ma 27 Qubitów.

2. Stosowanie permutacji: Generujemy dziesięć losowych wzorców permutacji (pattern_1 do pattern_10) z ustalonym ziarnem dla powtarzalności. Każdy wzorzec permutacji jest stosowany do oddzielnego Circuit kwantowego (qc_1 do qc_10).

3. Dekompozycja Circuit: Każda operacja permutacji jest dekomponowana do natywnych zestawów bramek kompatybilnych z docelowym sprzętem kwantowym. Analizujemy głębokość i liczbę bramek dwuqubitowych (bramek nielokalnych) dla każdego zdekompnowanego Circuit.

Wyniki dają wgląd w złożoność reprezentowania klasycznych problemów permutacji na urządzeniu kwantowym, demonstrując wymagania zasobowe dla różnych wzorców permutacji.

# Parameters
width = 27
num_circuits = 10

# Set random seed
np.random.seed(seed)

# Generate random patterns and circuits
patterns = [
    np.random.permutation(width).tolist() for _ in range(num_circuits)
]
circuits = {
    f"qc_{i}": generate_permutation_circuit(width, pattern)
    for i, pattern in enumerate(patterns, start=1)
}

# Display one of the circuits
circuits["qc_1"].decompose(reps=3).draw(output="mpl", fold=-1)

Krok 2: Optymalizacja problemu pod kątem wykonania na sprzęcie kwantowym

W tym kroku przeprowadzamy optymalizację przy użyciu przejść syntezy AI.

W przypadku przejść syntezy AI PassManager wymaga jedynie mapy sprzężeń backendu. Należy jednak pamiętać, że nie wszystkie mapy sprzężeń są kompatybilne — działają tylko te, na których zostało wytrenowane przejście AIPermutationSynthesis. Aktualnie przejście AIPermutationSynthesis obsługuje bloki o rozmiarach 65, 33 i 27 Qubitów. W tym przykładzie używamy 27-qubitowego QPU.

Dla porównania ocenimy wydajność syntezy AI w stosunku do ogólnych metod syntezy permutacji w Qiskit, w tym:

• synth_permutation_depth_lnn_kms: Ta metoda syntetyzuje Circuit permutacji dla architektury liniowej najbliższego sąsiada (LNN) przy użyciu algorytmu Kutina, Moultona i Smithline'a (KMS). Gwarantuje Circuit o głębokości co najwyżej $n$ i rozmiarze co najwyżej $n(n-1)/2$, gdzie zarówno głębokość, jak i rozmiar są mierzone w bramkach SWAP.

• synth_permutation_basic: To prosta implementacja, która syntetyzuje Circuit permutacji bez narzucania ograniczeń na łączność ani optymalizacji dla konkretnych architektur. Służy jako punkt odniesienia do porównywania wydajności z bardziej zaawansowanymi metodami.

Każda z tych metod reprezentuje odrębne podejście do syntezy sieci permutacji, zapewniając kompleksowy benchmark względem metod opartych na AI.

Więcej informacji o metodach syntezy w Qiskit znajdziesz w dokumentacji API Qiskit. Zdefiniuj mapę sprzężeń reprezentującą 27-qubitowy QPU.

coupling_map = [
    [1, 0],
    [2, 1],
    [3, 2],
    [3, 5],
    [4, 1],
    [6, 7],
    [7, 4],
    [7, 10],
    [8, 5],
    [8, 9],
    [8, 11],
    [11, 14],
    [12, 10],
    [12, 13],
    [12, 15],
    [13, 14],
    [16, 14],
    [17, 18],
    [18, 15],
    [18, 21],
    [19, 16],
    [19, 22],
    [20, 19],
    [21, 23],
    [23, 24],
    [25, 22],
    [25, 24],
    [26, 25],
]
CouplingMap(coupling_map).draw()

Transpiluj każdy z Circuit permutacji przy użyciu przejść syntezy AI i ogólnych metod syntezy.

results = []
pm_no_ai_synth = generate_preset_pass_manager(
    coupling_map=cm,
    optimization_level=1,  # set to 1 since we are using the synthesis methods
)

# Transpile and analyze all circuits
for i, (qc_name, qc) in enumerate(circuits.items(), start=1):
    pattern = patterns[i - 1]  # Get the corresponding pattern

    qc_depth_lnn_kms = synth_permutation_depth_lnn_kms(pattern)
    qc_basic = synth_permutation_basic(pattern)

    # AI synthesis
    results.append(
        synth_transpile_with_metrics(
            qc.decompose(reps=3),
            pm_ai,
            qc_name,
            "AI",
        )
    )

    # Depth-LNN-KMS Method
    results.append(
        synth_transpile_with_metrics(
            qc_depth_lnn_kms.decompose(reps=3),
            pm_no_ai_synth,
            qc_name,
            "Depth-LNN-KMS",
        )
    )

    # Basic Method
    results.append(
        synth_transpile_with_metrics(
            qc_basic.decompose(reps=3),
            pm_no_ai_synth,
            qc_name,
            "Basic",
        )
    )

results_df = pd.DataFrame(results)

Zapisz metryki (głębokość, liczba bramek, czas) dla każdego Circuit po transpilacji.

# Calculate averages for each metric
average_metrics = results_df.groupby("Method")[
    ["Depth (2Q)", "Gates", "Time (s)"]
].mean()
average_metrics = average_metrics.round(3)  # Round to two decimal places
print("\n=== Average Metrics ===")
print(average_metrics)

# Identify the best non-AI method based on least average depth
non_ai_methods = [
    method for method in results_df["Method"].unique() if method != "AI"
]
best_non_ai_method = average_metrics.loc[non_ai_methods][
    "Depth (2Q)"
].idxmin()
print(
    f"\nBest Non-AI Method (based on least average depth): {best_non_ai_method}"
)

# Compare AI to the best non-AI method
ai_metrics = average_metrics.loc["AI"]
best_non_ai_metrics = average_metrics.loc[best_non_ai_method]

comparison = {
    "Metric": ["Depth (2Q)", "Gates", "Time (s)"],
    "AI": [
        ai_metrics["Depth (2Q)"],
        ai_metrics["Gates"],
        ai_metrics["Time (s)"],
    ],
    best_non_ai_method: [
        best_non_ai_metrics["Depth (2Q)"],
        best_non_ai_metrics["Gates"],
        best_non_ai_metrics["Time (s)"],
    ],
    "Improvement (AI vs Best Non-AI)": [
        ai_metrics["Depth (2Q)"] - best_non_ai_metrics["Depth (2Q)"],
        ai_metrics["Gates"] - best_non_ai_metrics["Gates"],
        ai_metrics["Time (s)"] - best_non_ai_metrics["Time (s)"],
    ],
}

comparison_df = pd.DataFrame(comparison)
print("\n=== Comparison of AI vs Best Non-AI Method ===")
comparison_df

=== Average Metrics ===
               Depth (2Q)  Gates  Time (s)
Method
AI                   23.9   82.8     0.248
Basic                29.8   91.0     0.012
Depth-LNN-KMS        70.8  531.6     0.017

Best Non-AI Method (based on least average depth): Basic

=== Comparison of AI vs Best Non-AI Method ===

Metric      AI   Basic  Improvement (AI vs Best Non-AI)
0  Depth (2Q)  23.900  29.800                           -5.900
1       Gates  82.800  91.000                           -8.200
2    Time (s)   0.248   0.012                            0.236

Wyniki pokazują, że Transpiler AI przewyższa wszystkie inne metody syntezy Qiskit dla tego zestawu losowych Circuit permutacji. Kluczowe wnioski:

1. Głębokość: Transpiler AI osiąga najniższą średnią głębokość, co świadczy o doskonałej optymalizacji układów Circuit.
2. Liczba bramek: Znacząco redukuje liczbę bramek w porównaniu z innymi metodami, poprawiając wierność wykonania i wydajność.
3. Czas transpilacji: Wszystkie metody działają bardzo szybko w tej skali, co czyni je praktycznymi w użyciu. Niemniej Transpiler AI charakteryzuje się wyraźnym wzrostem czasu wykonania w porównaniu z tradycyjnymi metodami, ze względu na złożoność używanych modeli AI.

Wyniki te ustanawiają Transpiler AI jako najbardziej efektywne podejście dla tego benchmarku, szczególnie w zakresie optymalizacji głębokości i liczby bramek. Wykreśl wyniki, aby porównać wydajność przejść syntezy AI z ogólnymi metodami syntezy.

methods = results_df["Method"].unique()

fig, axs = plt.subplots(1, 3, figsize=(18, 5))

# Pivot the DataFrame and reorder columns to ensure AI is first
pivot_depth = results_df.pivot(
    index="Pattern", columns="Method", values="Depth (2Q)"
)[["AI", "Depth-LNN-KMS", "Basic"]]
pivot_gates = results_df.pivot(
    index="Pattern", columns="Method", values="Gates"
)[["AI", "Depth-LNN-KMS", "Basic"]]
pivot_time = results_df.pivot(
    index="Pattern", columns="Method", values="Time (s)"
)[["AI", "Depth-LNN-KMS", "Basic"]]

pivot_depth.plot(kind="bar", ax=axs[0], legend=False)
axs[0].set_title("Circuit Depth Comparison")
axs[0].set_ylabel("Depth")
axs[0].set_xlabel("Pattern")
axs[0].tick_params(axis="x", rotation=45)
pivot_gates.plot(kind="bar", ax=axs[1], legend=False)
axs[1].set_title("2Q Gate Count Comparison")
axs[1].set_ylabel("Number of 2Q Gates")
axs[1].set_xlabel("Pattern")
axs[1].tick_params(axis="x", rotation=45)
pivot_time.plot(
    kind="bar", ax=axs[2], legend=True, title="Legend"
)  # Show legend on the last plot
axs[2].set_title("Time Comparison")
axs[2].set_ylabel("Time (seconds)")
axs[2].set_xlabel("Pattern")
axs[2].tick_params(axis="x", rotation=45)
fig.suptitle(
    "Benchmarking AI Synthesis Methods vs Non-AI Synthesis Methods For Random Permutations Circuits",
    fontsize=16,
    y=1,
)

plt.tight_layout()
plt.show()

Ten wykres przedstawia indywidualne wyniki dla każdego Circuit (qc_1 do qc_10) w różnych metodach syntezy:

Choć wyniki te podkreślają skuteczność Transpilera AI dla Circuit permutacji, ważne jest, by uwzględnić jego ograniczenia. Metoda syntezy AI jest obecnie dostępna tylko dla określonych map sprzężeń, co może ograniczać jej szersze zastosowanie. Należy wziąć to pod uwagę przy ocenie jej użycia w różnych scenariuszach.

Ogólnie rzecz biorąc, Transpiler AI wykazuje obiecujące ulepszenia w optymalizacji głębokości i liczby bramek dla tych konkretnych Circuit, przy zachowaniu porównywalnych czasów transpilacji.

Krok 3: Wykonanie przy użyciu prymitywów Qiskit

Ponieważ ten samouczek skupia się na transpilacji, żadne eksperymenty nie będą wykonywane na urządzeniu kwantowym. Celem jest wykorzystanie optymalizacji z Kroku 2 w celu uzyskania transpilowanego Circuit o zredukowanej głębokości lub liczbie bramek.

Krok 4: Przetwarzanie końcowe i zwrócenie wyniku w żądanym formacie klasycznym

Ponieważ w tym notebooku nie ma wykonania, nie ma też wyników do przetwarzania końcowego.

Ankieta dotycząca samouczka

Prosimy o wypełnienie krótkiej ankiety, aby przekazać opinię na temat tego samouczka. Twoje spostrzeżenia pomogą nam ulepszyć ofertę treści i doświadczenie użytkownika.

Link do ankiety

Note: This survey is provided by IBM Quantum and relates to the original English content. To give feedback on doQumentation's website, translations, or code execution, please open a GitHub issue.