Úvod do Qiskit AI-powered transpiler service

Odhadované využití QPU: žádné (POZNÁMKA: Tento tutoriál nespouští úlohy, protože se zaměřuje na transpilaci)

Úvod

Qiskit AI-powered transpiler service (QTS) zavádí optimalizace založené na strojovém učení v průchodech pro směrování i syntézu. Tyto AI režimy byly navrženy tak, aby překonaly omezení tradiční transpilace, zejména pro rozsáhlé obvody a složité topologie hardwaru.

Od července 2025 byl Transpiler Service migrován na novou platformu IBM Quantum® Platform a není již k dispozici. Nejnovější informace o stavu Transpiler Service najdeš v dokumentaci transpiler service. AI transpiler lze stále používat lokálně, podobně jako standardní Qiskit transpilaci. Jednoduše nahraď generate_preset_pass_manager() za generate_ai_pass_manager(). Tato funkce sestaví pass manager, který integruje AI-powered průchody pro směrování a syntézu přímo do tvého lokálního pracovního postupu transpilace.

Klíčové vlastnosti AI průchodů

• Průchody pro směrování: AI-powered směrování dokáže dynamicky přizpůsobit cesty Qubitů na základě konkrétního obvodu a Backendu, čímž snižuje potřebu nadměrného počtu SWAP Gate.

  • AIRouting: Výběr rozmístění a směrování obvodu

• Průchody pro syntézu: AI techniky optimalizují dekompozici vícequbitových Gate a minimalizují počet dvoququbitových Gate, které jsou obvykle náchylnější k chybám.

  • AICliffordSynthesis: Syntéza Cliffordových Gate
  • AILinearFunctionSynthesis: Syntéza obvodu s lineárními funkcemi
  • AIPermutationSynthesis: Syntéza permutačního obvodu
  • AIPauliNetworkSynthesis: Syntéza obvodu Pauliho sítě (dostupná pouze v Qiskit Transpiler Service, nikoli v lokálním prostředí)

• Srovnání s tradiční transpilací: Standardní Qiskit Transpiler je robustní nástroj, který dokáže efektivně zpracovat širokou škálu kvantových obvodů. Avšak pokud obvody nabývají většího rozsahu nebo konfigurace hardwaru jsou složitější, AI průchody mohou přinést dodatečné optimalizační přínosy. Pomocí naučených modelů pro směrování a syntézu QTS dále zdokonaluje rozmístění obvodů a snižuje režii pro náročné nebo rozsáhlé kvantové úlohy.

Tento tutoriál hodnotí AI režimy s použitím průchodů pro směrování i syntézu a porovnává výsledky s tradiční transpilací, aby zdůraznil oblasti, kde AI přináší výkonnostní přínosy.

Více informací o dostupných AI průchodech najdeš v dokumentaci AI průchodů.

Proč používat AI pro transpilaci kvantových obvodů?

S tím, jak kvantové obvody rostou v rozsahu a složitosti, tradiční metody transpilace mají potíže s efektivní optimalizací rozmístění a snižováním počtu Gate. Větší obvody, zejména ty zahrnující stovky Qubitů, kladou na směrování a syntézu značné nároky kvůli omezením zařízení, omezenému propojení a chybovosti Qubitů.

Právě zde nabízí AI-powered transpilace potenciální řešení. Využitím technik strojového učení může AI-powered Transpiler v Qiskitu přijímat chytřejší rozhodnutí o směrování Qubitů a syntéze Gate, což vede k lepší optimalizaci rozsáhlých kvantových obvodů.

Stručné výsledky benchmarkingu

V benchmarkingových testech AI Transpiler konzistentně produkoval mělčí a kvalitnější obvody ve srovnání se standardním Qiskit Transpilerem. Pro tyto testy jsme použili výchozí strategii pass manageru Qiskitu, nakonfigurovanou pomocí [generate_preset_passmanager]. Ačkoli tato výchozí strategie je často účinná, může mít potíže s většími nebo složitějšími obvody. Naopak AI-powered průchody dosáhly průměrného snížení počtu dvoququbitových Gate o 24 % a snížení hloubky obvodu o 36 % pro velké obvody (100+ Qubitů) při transpilaci do heavy-hex topologie hardwaru IBM Quantum. Více informací o těchto benchmarcích najdeš na tomto blogu.

Tento tutoriál prozkoumává klíčové výhody AI průchodů a jak se porovnávají s tradičními 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

Požadavky

Před zahájením tohoto tutoriálu se ujisti, že máš nainstalováno následující:

• Qiskit SDK v1.0 nebo novější, s podporou vizualizace
• Qiskit Runtime (pip install qiskit-ibm-runtime) v0.22 nebo novější
• Qiskit IBM® Transpiler s lokálním AI režimem (pip install 'qiskit-ibm-transpiler[ai-local-mode]')

Nastavení

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)

Část I. Qiskit patterns

Pojďme se nyní podívat, jak používat AI transpiler service s jednoduchým kvantovým obvodem pomocí Qiskit patterns. Klíčem je vytvoření PassManager pomocí generate_ai_pass_manager() místo standardního generate_preset_pass_manager().

Krok 1: Mapování klasických vstupů na kvantový problém

V této části otestujeme AI Transpiler na obvodu efficient_su2, široce používaném hardware-efficient ansatzu. Tento obvod je zvláště relevantní pro variační kvantové algoritmy (například VQE) a úlohy kvantového strojového učení, což z něj činí ideální testovací případ pro hodnocení výkonu transpilace.

Obvod efficient_su2 se skládá ze střídajících se vrstev jednoququbitových rotací a propojovacích Gate jako CNOT. Tyto vrstvy umožňují flexibilní prozkoumávání prostoru kvantových stavů při zachování zvládnutelné hloubky Gate. Optimalizací tohoto obvodu se snažíme snížit počet Gate, zlepšit věrnost a minimalizovat šum. To z něj činí silného kandidáta pro testování efektivity AI Transpileru.

# 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: Optimalizace problému pro spuštění na kvantovém hardwaru

Výběr Backendu

V tomto příkladu vybereme nejméně vytížený provozní Backend IBM Quantum, který není simulátorem a má alespoň 100 Qubitů:

Poznámka: Protože nejméně vytížený Backend se může v čase měnit, pro různá spuštění mohou být vybrána různá zařízení. Vlastnosti specifické pro zařízení, jako jsou coupling mapy, mohou vést k rozdílům v transpilovaných obvodech.

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

Vytvoření AI a tradičního pass manageru

Abychom zhodnotili efektivitu AI Transpileru, provedeme dvě transpilační spuštění. Nejprve transpilujeme obvod pomocí AI Transpileru. Poté provedeme porovnání transpilací téhož obvodu bez AI Transpileru, s použitím tradičních metod. Oba transpilační procesy budou používat stejnou coupling mapu ze zvoleného Backendu a úroveň optimalizace nastavenou na 3 pro spravedlivé srovnání.

Obě tyto metody odrážejí standardní přístup k vytváření instancí PassManager pro transpilaci obvodů v Qiskitu.

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 obvody a zaznamenej časy.

# 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

V tomto testu porovnáváme výkon AI Transpileru a standardní metody transpilace na obvodu efficient_su2. AI Transpiler dosahuje znatelně mělčí hloubky obvodu při zachování podobného počtu Gate.

• Hloubka obvodu: AI Transpiler produkuje obvod s nižší dvoququbitovou hloubkou. To je očekávané, protože AI průchody jsou trénovány k optimalizaci hloubky tím, že se učí vzory interakcí Qubitů a efektivněji využívají konektivitu hardwaru než heuristiky založené na pravidlech.

• Počet Gate: Celkový počet Gate zůstává mezi oběma metodami podobný. To odpovídá očekáváním, protože standardní transpilace na bázi SABRE explicitně minimalizuje počet swap operací, který dominuje režii Gate. AI Transpiler místo toho upřednostňuje celkovou hloubku a příležitostně může obětovat několik dodatečných Gate za kratší cestu vykonávání.

• Čas transpilace: AI Transpiler trvá déle než standardní metoda. Je to způsobeno dodatečnými výpočetními náklady na vyvolání naučených modelů během směrování a syntézy. Naproti tomu Transpiler na bázi SABRE je nyní výrazně rychlejší po přepsání a optimalizaci v jazyce Rust, který poskytuje vysoce efektivní heuristické směrování ve velkém měřítku.

Je důležité poznamenat, že tyto výsledky jsou založeny pouze na jednom obvodu. Pro získání komplexního pochopení toho, jak se AI Transpiler porovnává s tradičními metodami, je nutné testovat různé obvody. Výkon QTS se může výrazně lišit v závislosti na typu optimalizovaného obvodu. Pro širší srovnání si prohlédni výše uvedené benchmarky nebo navštiv blog.

Krok 3: Spuštění pomocí Qiskit primitiv

Protože se tento tutoriál zaměřuje na transpilaci, nebudou na kvantovém zařízení provedeny žádné experimenty. Cílem je využít optimalizace z kroku 2 k získání transpilovaného obvodu s nižší hloubkou nebo menším počtem hradel.

Krok 4: Postprocessing a vrácení výsledku v požadovaném klasickém formátu

Protože v tomto notebooku neprobíhá žádné spuštění, nejsou k dispozici žádné výsledky ke zpracování.

Část II. Analýza a benchmarking transpilovaných obvodů

V této části ukážeme, jak analyzovat transpilovaný obvod a podrobněji ho porovnat s původní verzí. Zaměříme se na metriky jako hloubka obvodu, počet hradel a čas transpilace, abychom posoudili efektivitu optimalizace. Dále probereme, jak se výsledky mohou lišit v závislosti na různých typech obvodů, a nabídneme přehled o celkovém výkonu transpilátoru v různých scénářích.

# 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

Průměrné procentuální snížení pro každou metriku. Kladné hodnoty znamenají zlepšení, záporné zhoršení.

# 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()

Výkon AI transpilátoru se výrazně liší v závislosti na typu optimalizovaného obvodu. V některých případech dosahuje znatelného snížení hloubky obvodu a počtu hradel ve srovnání se standardním transpilátorem. Tato zlepšení však často přicházejí s podstatným nárůstem doby běhu.

U určitých typů obvodů může AI transpilátor přinést o něco lepší výsledky z hlediska hloubky obvodu, ale zároveň může vést ke zvýšení počtu hradel a výraznému poklesu výkonu z pohledu doby běhu. Tato pozorování naznačují, že přínosy AI transpilátoru nejsou rovnoměrné napříč všemi typy obvodů. Jeho efektivita závisí na konkrétních vlastnostech obvodu, takže je vhodnější pro určité případy použití než pro jiné.

Kdy by uživatelé měli zvolit AI-powered transpilaci?

AI-powered transpilátor v Qiskitu vyniká ve scénářích, kde tradiční metody transpilace narážejí na limity, zejména u rozsáhlých a složitých kvantových obvodů. Pro obvody zahrnující stovky qubitů nebo ty, které cílí na hardware se složitými coupling mapami, nabízí AI transpilátor nadřazenou optimalizaci z hlediska hloubky obvodu, počtu hradel a efektivity doby běhu. V benchmarkingových testech konzistentně překonal tradiční metody, přičemž dosahoval výrazně mělčích obvodů a snižoval počty hradel, což je klíčové pro zlepšení výkonu a potlačení šumu na skutečném kvantovém hardwaru.

Uživatelé by měli zvážit AI-powered transpilaci při práci s:

• Velkými obvody, kde tradiční metody neumí efektivně zvládnout daný rozsah.
• Složitými topologiemi hardwaru, kde vyvstávají problémy s konektivitou zařízení a routováním.
• Aplikacemi citlivými na výkon, kde je klíčové snižování hloubky obvodu a zlepšování věrnosti.

Část III. Průzkum AI-powered syntézy permutačních sítí

Permutační sítě jsou základním stavebním kamenem kvantového výpočtu, zejména pro systémy omezené restriktivními topologiemi. Tyto sítě umožňují interakce na dlouhé vzdálenosti dynamickým swapováním qubitů, aby simulovaly konektivitu každý s každým na hardwaru s omezenou konektivitou. Takové transformace jsou nezbytné pro implementaci složitých kvantových algoritmů na zařízeních blízké budoucnosti, kde interakce často přesahují nejbližší sousedy.

V této části zdůrazňujeme syntézu permutačních sítí jako přesvědčivý příklad použití AI-powered transpilátoru v Qiskitu. Konkrétně průchod AIPermutationSynthesis využívá optimalizaci řízenou umělou inteligencí ke generování efektivních obvodů pro úlohy permutace qubitů. Oproti tomu generické přístupy k syntéze mají často potíže s vyvažováním počtu hradel a hloubky obvodu, zejména ve scénářích s hustými interakcemi qubitů nebo při snaze dosáhnout plné konektivity.

Projdeme si příklad Qiskit patterns ukazující syntézu permutační sítě pro dosažení konektivity každý s každým pro sadu qubitů. Porovnáme výkon AIPermutationSynthesis se standardními metodami syntézy v Qiskitu. Tento příklad ukáže, jak AI transpilátor optimalizuje pro nižší hloubku obvodu a počet hradel, a zdůrazní jeho výhody v praktických kvantových pracovních postupech. Pro aktivaci průchodu AI syntézy použijeme funkci generate_ai_pass_manager() s parametrem include_ai_synthesis nastaveným na True.

Krok 1: Mapování klasických vstupů na kvantový problém

Pro reprezentaci klasického problému permutace na kvantovém počítači začínáme definováním struktury kvantových obvodů. Pro tento příklad:

1. Inicializace kvantového obvodu: Alokujeme 27 qubitů, abychom odpovídali backendu, který budeme používat a který má 27 qubitů.

2. Aplikace permutací: Vygenerujeme deset náhodných permutačních vzorců (pattern_1 až pattern_10) s pevným seedem pro reprodukovatelnost. Každý permutační vzorec je aplikován na samostatný kvantový obvod (qc_1 až qc_10).

3. Dekompozice obvodu: Každá permutační operace je rozložena na nativní sady hradel kompatibilní s cílovým kvantovým hardwarem. Analyzujeme hloubku a počet dvouqubitových hradel (nelokálních hradel) pro každý dekompozovaný obvod.

Výsledky poskytují přehled o složitosti reprezentace klasických permutačních problémů na kvantovém zařízení a demonstrují požadavky na zdroje pro různé permutační vzorce.

# 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: Optimalizace problému pro spuštění na kvantovém hardwaru

V tomto kroku pokračujeme s optimalizací pomocí AI syntézních průchodů.

Pro AI syntézní průchody potřebuje PassManager pouze coupling map backendu. Je však důležité poznamenat, že ne všechny coupling mapy jsou kompatibilní; fungují pouze ty, na kterých byl průchod AIPermutationSynthesis natrénován. V současné době průchod AIPermutationSynthesis podporuje bloky o velikostech 65, 33 a 27 qubitů. V tomto příkladu používáme 27-qubitové QPU.

Pro srovnání vyhodnotíme výkon AI syntézy oproti obecným metodám syntézy permutací v Qiskitu, včetně:

• synth_permutation_depth_lnn_kms: Tato metoda syntetizuje permutační Circuit pro architekturu lineárního nejbližšího souseda (LNN) pomocí algoritmu Kutina, Moultona a Smithlinea (KMS). Zaručuje Circuit s hloubkou nejvýše $n$ a velikostí nejvýše $n(n-1)/2$, přičemž hloubka i velikost jsou měřeny v počtu SWAP Gates.

• synth_permutation_basic: Jedná se o přímočarou implementaci, která syntetizuje permutační Circuits bez omezení na konektivitu nebo optimalizaci pro konkrétní architektury. Slouží jako výchozí bod pro porovnání výkonu s pokročilejšími metodami.

Každá z těchto metod představuje odlišný přístup k syntéze permutačních sítí a poskytuje tak komplexní benchmark oproti metodám řízeným umělou inteligencí.

Více informací o metodách syntézy v Qiskitu najdeš v dokumentaci Qiskit API. Definuj coupling map reprezentující 27-qubitové 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ždý z permutačních Circuits pomocí AI syntézních průchodů a obecných metod syntézy.

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)

Zaznamenej metriky (hloubka, počet Gates, čas) pro každý Circuit po transpilaci.

# 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

Výsledky ukazují, že AI Transpiler překonává všechny ostatní metody syntézy v Qiskitu pro tuto sadu náhodných permutačních Circuits. Klíčová zjištění zahrnují:

1. Hloubka: AI Transpiler dosahuje nejnižší průměrné hloubky, což svědčí o nadřazené optimalizaci rozvržení Circuit.
2. Počet Gates: Výrazně snižuje počet Gates ve srovnání s ostatními metodami, čímž zlepšuje věrnost a efektivitu spuštění.
3. Čas transpilace: Všechny metody běží na této škále velmi rychle, takže jsou prakticky použitelné. AI Transpiler má však oproti tradičním metodám znatelně vyšší dobu běhu kvůli složitosti použitých AI modelů.

Tyto výsledky potvrzují, že AI Transpiler je pro tento benchmark nejefektivnějším přístupem, zejména z hlediska optimalizace hloubky a počtu Gates. Vykresli výsledky pro porovnání výkonu AI syntézních průchodů oproti obecným metodám syntézy.

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

Tento graf zvýrazňuje jednotlivé výsledky pro každý Circuit (qc_1 až qc_10) napříč různými metodami syntézy:

Ačkoli tyto výsledky zdůrazňují efektivitu AI Transpileru pro permutační Circuits, je důležité vzít v úvahu jeho omezení. Metoda AI syntézy je v současné době dostupná pouze pro určité coupling mapy, což může omezovat její širší použitelnost. Toto omezení je třeba zohlednit při hodnocení jejího použití v různých scénářích.

Celkově AI Transpiler vykazuje slibná zlepšení v optimalizaci hloubky a počtu Gates pro tyto konkrétní Circuits při zachování srovnatelných časů transpilace.

Krok 3: Spuštění pomocí Qiskit primitiv

Protože tento tutoriál se zaměřuje na transpilaci, nebudou na kvantovém zařízení spuštěny žádné experimenty. Cílem je využít optimalizace z kroku 2 k získání transpilovaného Circuit se sníženou hloubkou nebo počtem Gates.

Krok 4: Následné zpracování a vrácení výsledku v požadovaném klasickém formátu

Protože v tomto notebooku neprobíhá žádné spuštění, nejsou k dispozici žádné výsledky ke zpracování.

Průzkum o tutoriálu

Vyplň prosím tento krátký průzkum a poskytni nám zpětnou vazbu k tomuto tutoriálu. Tvoje podněty nám pomohou zlepšit naši nabídku obsahu a uživatelský zážitek.

Odkaz na průzkum

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.