Pengenalan Transpiler bertenaga AI Qiskit

Perkiraan penggunaan: 5 menit di IBM Heron (CATATAN: Ini hanya perkiraan. Waktu eksekusi aktual kamu bisa berbeda.)

Hasil belajar

Setelah menyelesaikan tutorial ini, pengguna diharapkan memahami:

• Cara menggunakan Transpiler bertenaga AI (generate_ai_pass_manager) sebagai pengganti langsung untuk transpiler standar
• Bagaimana Transpiler bertenaga AI dibandingkan dengan transpiler default dalam hal two-qubit depth, jumlah Gate, dan waktu transpilasi
• Cara menggunakan mirror circuits untuk mengevaluasi kualitas transpilasi melalui eksekusi hardware

Prasyarat

Kami menyarankan pengguna untuk sudah familiar dengan topik-topik berikut sebelum mengikuti tutorial ini:

• Transpile circuits
• Configure preset pass managers
• AI-powered transpiler passes

Latar Belakang

Transpiler bertenaga AI Qiskit memperkenalkan pass transpilasi berbasis machine learning yang dapat menghasilkan Circuit yang lebih pendek dan lebih efisien secara hardware dibandingkan metode heuristik tradisional seperti SABRE. Circuit yang lebih pendek mengakumulasi lebih sedikit noise, yang secara langsung meningkatkan kualitas hasil pada hardware kuantum nyata.

Dalam tutorial ini kita membandingkan dua strategi transpilasi:

Strategi	API
Default	generate_preset_pass_manager(optimization_level=3, ...)
AI	generate_ai_pass_manager(optimization_level=1, ai_optimization_level=3, ...)

Kita mengukur tiga metrik untuk setiap strategi: two-qubit gate depth, total jumlah Gate, dan waktu transpilasi.

Benchmark Transpiler bertenaga AI

Dalam pengujian benchmark, Transpiler bertenaga AI secara konsisten menghasilkan Circuit yang lebih dangkal dan berkualitas lebih tinggi dibandingkan transpiler Qiskit standar. Untuk pengujian ini, kami menggunakan strategi pass manager default Qiskit yang dikonfigurasi dengan generate_preset_pass_manager. Meskipun strategi default ini sering efektif, ia bisa kesulitan dengan Circuit yang lebih besar atau lebih kompleks. Sebaliknya, pass bertenaga AI mencapai rata-rata pengurangan 24% dalam jumlah Gate dua-Qubit dan pengurangan 36% dalam kedalaman Circuit untuk Circuit besar (100+ qubit) saat melakukan transpilasi ke topologi heavy-hex hardware IBM Quantum®. Untuk informasi lebih lanjut tentang benchmark ini, lihat blog ini.

Tutorial ini mengeksplorasi manfaat utama AI passes dan bagaimana perbandingannya dengan metode tradisional.

Persyaratan

Sebelum memulai tutorial ini, pastikan kamu sudah menginstal hal-hal berikut:

• Qiskit SDK v2.0 atau lebih baru, dengan dukungan visualisasi
• Qiskit Runtime (pip install qiskit-ibm-runtime) v0.22 atau lebih baru
• Qiskit IBM Transpiler dengan mode AI lokal (pip install 'qiskit-ibm-transpiler[ai-local-mode]')
• Qiskit Aer (pip install qiskit-aer)

Pengaturan

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

from qiskit import QuantumCircuit
from qiskit.circuit.random import random_circuit
from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2
from qiskit_ibm_transpiler import generate_ai_pass_manager
from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel, depolarizing_error
import matplotlib.pyplot as plt
from statistics import mean, stdev
import time
import logging

seed = 42

def transpile_with_metrics(pass_manager, circuit):
    """Transpile a circuit and return the result along with key metrics."""
    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": round(elapsed, 3),
    }

def remap_to_contiguous(tqc):
    """Remap a transpiled circuit to use contiguous qubit indices.

    Transpiled circuits target specific physical qubits (e.g., qubit 45, 67)
    on a large backend. This remaps them to 0, 1, 2, ... so Aer only
    simulates the active qubits."""
    active = sorted(
        {tqc.find_bit(q).index for inst in tqc.data for q in inst.qubits}
    )
    qubit_map = {old: new for new, old in enumerate(active)}
    new_qc = QuantumCircuit(len(active))
    for inst in tqc.data:
        old_indices = [tqc.find_bit(q).index for q in inst.qubits]
        new_qc.append(inst.operation, [qubit_map[i] for i in old_indices])
    return new_qc

def build_mirror_circuit(tqc, simulate=True):
    """Build a mirror circuit: U followed by U-dagger, with measurements.

    The expected output is always |0...0>, so measuring the survival
    probability reveals how much noise each transpilation strategy adds.

    Args:
        tqc: A transpiled circuit.
        simulate: If True (default), remap to contiguous qubits so Aer
            only simulates the active qubits. If False, keep the full
            physical layout for hardware execution."""
    if simulate:
        tqc = remap_to_contiguous(tqc)
    mirror = tqc.compose(tqc.inverse())
    mirror.measure_all()
    return mirror

def print_summary(results):
    """Print a summary of each metric as mean +/- stdev across all circuits,
    along with the mean percentage improvement of AI over Default."""
    metrics = [
        ("Depth 2Q", "Depth 2Q (Default)", "Depth 2Q (AI)"),
        ("Gate Count", "Gate Count (Default)", "Gate Count (AI)"),
        ("Time (s)", "Time (Default)", "Time (AI)"),
    ]
    header = (
        f"{'Metric':<12}{'Default (mean +/- std)':>24}"
        f"{'AI (mean +/- std)':>22}{'AI % improvement':>22}"
    )
    print(header)
    print("-" * len(header))
    for label, col_def, col_ai in metrics:
        defaults = [r[col_def] for r in results]
        ais = [r[col_ai] for r in results]
        pct = [(d - a) / d * 100 for d, a in zip(defaults, ais)]
        default_str = f"{mean(defaults):.1f} +/- {stdev(defaults):.1f}"
        ai_str = f"{mean(ais):.1f} +/- {stdev(ais):.1f}"
        pct_str = f"{mean(pct):+.1f}% +/- {stdev(pct):.1f}%"
        print(f"{label:<12}{default_str:>24}{ai_str:>22}{pct_str:>22}")

def plot_metrics_and_pct(results, title_prefix):
    """Plot metric comparisons and percentage improvement of AI over Default."""
    qubits = [r["Qubits"] for r in results]
    metrics = [
        ("Depth 2Q (Default)", "Depth 2Q (AI)", "Two-Qubit Depth"),
        ("Gate Count (Default)", "Gate Count (AI)", "Gate Count"),
        ("Time (Default)", "Time (AI)", "Transpilation Time"),
    ]

    # Row 1: raw metric comparison
    fig, axs = plt.subplots(1, 3, figsize=(21, 5))
    fig.suptitle(
        f"{title_prefix}: Metric Comparison",
        fontsize=15,
        fontweight="bold",
        y=1.02,
    )
    for ax, (col_def, col_ai, label) in zip(axs, metrics):
        ax.plot(qubits, [r[col_def] for r in results], "o-", label="Default")
        ax.plot(qubits, [r[col_ai] for r in results], "s-", label="AI")
        ax.set_title(label)
        ax.set_xlabel("Number of Qubits")
        ax.set_ylabel(label)
        ax.legend()
    plt.tight_layout()
    plt.show()

    # Row 2: percentage improvement
    fig, axs = plt.subplots(1, 3, figsize=(21, 5))
    fig.suptitle(
        f"{title_prefix}: % Improvement of AI over Default",
        fontsize=15,
        fontweight="bold",
        y=1.02,
    )
    for ax, (col_def, col_ai, label) in zip(axs, metrics):
        pct = [(r[col_def] - r[col_ai]) / r[col_def] * 100 for r in results]
        ax.axhline(
            0, color="#1f77b4", linewidth=2, label="Default (baseline)"
        )
        ax.plot(qubits, pct, "s-", color="#ff7f0e", label="AI")
        ax.fill_between(qubits, 0, pct, alpha=0.15, color="#ff7f0e")
        ax.set_title(label)
        ax.set_xlabel("Number of Qubits")
        ax.set_ylabel("% Improvement")
        ax.legend()
    plt.tight_layout()
    plt.show()

# Suppress verbose AI-powered transpiler logs
logging.getLogger(
    "qiskit_ibm_transpiler.wrappers.ai_local_synthesis"
).setLevel(logging.WARNING)

Contoh simulator skala kecil

Langkah 1: Petakan input klasik ke masalah kuantum

Kita membuat 20 Circuit acak dengan kedalaman 4, di mana jumlah qubit berkisar dari enam hingga 25. Circuit-Circuit ini akan menjadi kasus uji untuk membandingkan strategi transpilasi.

num_circuits_sim = 20
depth_sim = 4
qubit_range_sim = list(range(6, 26))

circuits_sim = [
    # We have only two qubit gates, as those test how well the transpiler can optimize the circuit.
    random_circuit(
        num_qubits=n,
        depth=depth_sim,
        max_operands=2,
        num_operand_distribution={2: 1},
        seed=seed + i,
    )
    for i, n in enumerate(qubit_range_sim)
]

print(
    f"Created {len(circuits_sim)} circuits with qubit counts: {qubit_range_sim}"
)
circuits_sim[0].draw(output="mpl", fold=-1)

Created 20 circuits with qubit counts: [6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]

Langkah 2: Optimalkan masalah untuk eksekusi hardware kuantum

Kita membuat pass manager default (SABRE) untuk Backend yang dipilih. Kedua strategi transpilasi menargetkan coupling map penuh Backend. Simulasi lokal tetap dapat dikelola karena langkah simulasi menggunakan remap_to_contiguous untuk menomori ulang setiap Circuit yang telah ditranspilasi hanya pada qubit aktifnya, sehingga Aer hanya mensimulasikan qubit-qubit tersebut dan bukan seluruh perangkat.

service = QiskitRuntimeService()
backend = service.least_busy(
    min_num_qubits=100, operational=True, simulator=False
)

pm_default_sim = generate_preset_pass_manager(
    optimization_level=3,
    backend=backend,
    seed_transpiler=seed,
)

results_sim = []

for i, qc in enumerate(circuits_sim):
    n = qubit_range_sim[i]

    qc_default, m_default = transpile_with_metrics(pm_default_sim, qc)

    # Create a fresh AI pass manager each iteration to avoid stale layout state
    pm_ai = generate_ai_pass_manager(
        optimization_level=1,
        ai_optimization_level=3,
        backend=backend,
    )
    qc_ai, m_ai = transpile_with_metrics(pm_ai, qc)

    results_sim.append(
        {
            "Qubits": n,
            "Depth 2Q (Default)": m_default["depth_2q"],
            "Depth 2Q (AI)": m_ai["depth_2q"],
            "Gate Count (Default)": m_default["gate_count"],
            "Gate Count (AI)": m_ai["gate_count"],
            "Time (Default)": m_default["time_s"],
            "Time (AI)": m_ai["time_s"],
        }
    )

print_summary(results_sim)

Fetching 4 files:   0%|          | 0/4 [00:00<?, ?it/s]

Metric        Default (mean +/- std)     AI (mean +/- std)      AI % improvement
--------------------------------------------------------------------------------
Depth 2Q               33.0 +/- 12.9          26.4 +/- 8.0      +15.8% +/- 17.6%
Gate Count           522.0 +/- 266.0       560.5 +/- 279.1        -9.0% +/- 9.0%
Time (s)                 0.0 +/- 0.0           0.2 +/- 0.1    -893.6% +/- 362.9%

Tabel ringkasan menunjukkan rata-rata dan standar deviasi setiap metrik di seluruh 20 Circuit, beserta rata-rata persentase peningkatan Transpiler bertenaga AI dibandingkan default. Nilai positif menunjukkan Transpiler bertenaga AI menghasilkan hasil yang lebih baik; nilai negatif menunjukkan transpiler default lebih unggul.

Untuk contoh skala kecil ini, Transpiler bertenaga AI mencapai sekitar 16% two-qubit depth yang lebih rendah rata-rata, namun dengan biaya sekitar 9% jumlah Gate yang lebih tinggi. Ini menyoroti trade-off utama saat memilih antara dua strategi: Transpiler bertenaga AI memprioritaskan pengurangan kedalaman (lebih sedikit lapisan sekuensial Gate dua-Qubit), sedangkan transpiler default (SABRE) memprioritaskan meminimalkan total jumlah Gate (lebih sedikit penyisipan SWAP). Bergantung pada aplikasimu, satu metrik mungkin lebih penting dari yang lain.

plot_metrics_and_pct(results_sim, "Small-Scale Random Circuits")

Two-qubit depth: Transpiler bertenaga AI umumnya menghasilkan Circuit dengan two-qubit depth yang lebih rendah. Depth adalah salah satu metrik utama yang dilatih model routing AI untuk dioptimalkan, dan peningkatannya terlihat di sebagian besar ukuran Circuit, meski SABRE terkadang menyamainya atau mengunggulinya pada Circuit individual.

Jumlah Gate: Hasilnya hampir sebanding pada skala ini, dengan SABRE memiliki sedikit keunggulan secara keseluruhan. Heuristik routing SABRE dirancang untuk meminimalkan jumlah Gate SWAP yang disisipkan, yang secara langsung mengurangi jumlah Gate. Pada ukuran Circuit kecil, perbedaannya tidak terlalu besar.

Waktu transpilasi: Waktu proses SABRE hampir konstan terlepas dari jumlah qubit, sehingga ukuran Circuit sedikit berpengaruh pada waktu transpilasi di skala ini. Logika routing inti SABRE sangat dioptimalkan (sebagian besar diimplementasikan dalam Rust). Transpiler bertenaga AI memerlukan waktu yang lebih lama dan skalanya bertumbuh seiring ukuran Circuit, meski waktu absolutnya tetap wajar untuk penggunaan interaktif.

Langkah 3: Eksekusi menggunakan Qiskit primitives

Untuk mengevaluasi dampak transpilasi pada fidelitas Circuit, buat mirror circuits dari kasus 10-qubit dan jalankan di simulator Aer dengan noise model sederhana. Output yang diharapkan dari mirror circuit selalu bitstring all-zeros, sehingga probabilitas mengukur $|0\rangle^{\otimes n}$ menunjukkan seberapa baik setiap strategi transpilasi mempertahankan fidelitas.

# Use the 10-qubit circuit (index where qubits == 10)
idx_10q = qubit_range_sim.index(10)

qc_10q = circuits_sim[idx_10q]
qc_default_10q, _ = transpile_with_metrics(pm_default_sim, qc_10q)

pm_ai = generate_ai_pass_manager(
    optimization_level=1,
    ai_optimization_level=3,
    backend=backend,
)
qc_ai_10q, _ = transpile_with_metrics(pm_ai, qc_10q)

tqc_methods = {
    "Default": qc_default_10q,
    "AI": qc_ai_10q,
}

print(
    f"Default: depth {qc_default_10q.depth()}, gates {qc_default_10q.size()}"
)
print(f"AI:      depth {qc_ai_10q.depth()}, gates {qc_ai_10q.size()}")

Default: depth 84, gates 280
AI:      depth 91, gates 343

# Build a simple depolarizing noise model
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(
    depolarizing_error(0.001, 1),
    ["sx", "x", "rz"],  # ~0.1% per 1Q gate
)
noise_model.add_all_qubit_quantum_error(
    depolarizing_error(0.01, 2),
    ["cx", "ecr"],  # ~1% per 2Q gate
)

aer_sim = AerSimulator(noise_model=noise_model)

shots = 10000
survival_probs = {}

for method, tqc in tqc_methods.items():
    mirror = build_mirror_circuit(tqc, simulate=True)

    sampler = SamplerV2(mode=aer_sim)
    job = sampler.run([mirror], shots=shots)
    counts = job.result()[0].data.meas.get_counts()

    all_zeros = "0" * mirror.num_qubits
    survival = counts.get(all_zeros, 0) / shots
    survival_probs[method] = survival
    print(
        f"{method:8s}  P(|00...0>) = {survival:.4f}  ({counts.get(all_zeros, 0)}/{shots})"
    )

Default   P(|00...0>) = 0.8460  (8460/10000)
AI        P(|00...0>) = 0.8121  (8121/10000)

Kita menjalankan kedua mirror circuits melalui simulator Aer dengan noise model depolarizing sederhana. Probabilitas bertahan hidup, yang didefinisikan sebagai fraksi shot yang mengembalikan bitstring all-zeros, mengkuantifikasi berapa banyak noise yang diperkenalkan oleh setiap strategi transpilasi.

Langkah 4: Post-process dan kembalikan hasil dalam format klasik yang diinginkan

Kita mengekstrak probabilitas mengukur bitstring all-zeros dari kedua run. Probabilitas bertahan hidup yang lebih tinggi menunjukkan fidelitas yang lebih baik, artinya transpilasi memperkenalkan lebih sedikit noise. Plot di bawah ini menunjukkan komplemen, 1 - P(|0...0>), sehingga bar yang lebih rendah menunjukkan fidelitas yang lebih baik dan perbedaan kecil dalam error lebih mudah dilihat.

# Plot 1 - P(|0...0>), the probability of an erroneous (non-zero) outcome.
# A lower bar means the transpilation introduced less noise.
error_probs = {method: 1 - p for method, p in survival_probs.items()}

fig, ax = plt.subplots(figsize=(6, 4))
ax.bar(
    error_probs.keys(),
    error_probs.values(),
    color=["steelblue", "coral"],
)
ax.set_ylabel("1 - P(|0...0>)")
ax.set_title("Mirror Circuit Error (10-qubit, Aer Simulator)")
ax.set_ylim(0, 1)
plt.tight_layout()
plt.show()

Dalam kasus ini, transpiler default menghasilkan Circuit yang lebih dangkal sekaligus lebih kecil untuk instance 10-qubit tertentu ini, sehingga fidelitasnya yang lebih tinggi sudah diperkirakan. Hasil per-Circuit bervariasi: seperti yang ditunjukkan tabel ringkasan di atas, keunggulan Transpiler bertenaga AI adalah pada two-qubit depth yang lebih rendah rata-rata, bukan pada setiap Circuit individual. Strategi mana yang menghasilkan fidelitas lebih tinggi bergantung pada besarnya perbedaan setiap metrik, karakteristik noise hardware, dan struktur Circuit. Di bawah noise model depolarizing seragam, total jumlah Gate sering kali memiliki dampak yang lebih langsung pada accumulated error daripada depth saja.

Contoh hardware skala besar

Langkah 1-4

Di sini semua detail ini digabungkan menjadi alur kerja yang jelas pada skala yang lebih besar, yang kemudian dijalankan pada hardware kuantum nyata.

Kode di bawah ini membuat 25 Circuit acak dengan kedalaman 8, di mana jumlah qubit berkisar dari 26 hingga 50. Circuit-Circuit ini kemudian ditranspilasi dengan kedua strategi dan metrik yang sama dikumpulkan. Kemudian kita membuat mirror circuits dari kasus 26-qubit dan mengirimkannya ke Backend nyata.

# -------------------------Step 1-------------------------
num_circuits_hw = 25
depth_hw = 8
qubit_range_hw = list(range(26, 51))

circuits_hw = [
    # We have only two qubit gates, as those test how well the transpiler can optimize the circuit.
    random_circuit(
        num_qubits=n,
        depth=depth_hw,
        max_operands=2,
        num_operand_distribution={2: 1},
        seed=seed + i,
    )
    for i, n in enumerate(qubit_range_hw)
]

print(
    f"Created {len(circuits_hw)} circuits with qubit counts: {qubit_range_hw}"
)

Created 25 circuits with qubit counts: [26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50]

# -------------------------Step 2-------------------------
pm_default = generate_preset_pass_manager(
    optimization_level=3,
    backend=backend,
    seed_transpiler=seed,
)

results_hw = []

for i, qc in enumerate(circuits_hw):
    n = qubit_range_hw[i]

    qc_default, m_default = transpile_with_metrics(pm_default, qc)

    # Create a fresh AI pass manager each iteration to avoid stale layout state
    pm_ai = generate_ai_pass_manager(
        optimization_level=1,
        ai_optimization_level=3,
        backend=backend,
    )
    qc_ai, m_ai = transpile_with_metrics(pm_ai, qc)

    results_hw.append(
        {
            "Qubits": n,
            "Depth 2Q (Default)": m_default["depth_2q"],
            "Depth 2Q (AI)": m_ai["depth_2q"],
            "Gate Count (Default)": m_default["gate_count"],
            "Gate Count (AI)": m_ai["gate_count"],
            "Time (Default)": m_default["time_s"],
            "Time (AI)": m_ai["time_s"],
        }
    )

print_summary(results_hw)

Metric        Default (mean +/- std)     AI (mean +/- std)      AI % improvement
--------------------------------------------------------------------------------
Depth 2Q              217.4 +/- 50.4        191.0 +/- 35.6      +10.9% +/- 10.7%
Gate Count         4513.3 +/- 1394.3     5227.1 +/- 1536.4       -16.4% +/- 5.8%
Time (s)                 0.1 +/- 0.0           3.5 +/- 1.5   -3588.2% +/- 643.6%

plot_metrics_and_pct(results_hw, "Large-Scale Random Circuits")

# -------------------------Step 3-------------------------
# Build mirror circuits from the 26-qubit case
idx_26q = qubit_range_hw.index(26)

qc_26q = circuits_hw[idx_26q]
qc_default_26q, _ = transpile_with_metrics(pm_default, qc_26q)

pm_ai = generate_ai_pass_manager(
    optimization_level=1,
    ai_optimization_level=3,
    backend=backend,
)
qc_ai_26q, _ = transpile_with_metrics(pm_ai, qc_26q)

mirror_default_hw = build_mirror_circuit(qc_default_26q, simulate=False)
mirror_ai_hw = build_mirror_circuit(qc_ai_26q, simulate=False)

# Re-transpile to basis gates (the inverse can introduce gates like sxdg)
pm_basis = generate_preset_pass_manager(
    optimization_level=0,
    backend=backend,
)
mirror_default_hw = pm_basis.run(mirror_default_hw)
mirror_ai_hw = pm_basis.run(mirror_ai_hw)

print(
    f"Mirror circuit (Default): depth {mirror_default_hw.depth()}, gates {mirror_default_hw.size()}"
)
print(
    f"Mirror circuit (AI):      depth {mirror_ai_hw.depth()}, gates {mirror_ai_hw.size()}"
)

# Submit to real hardware
sampler_hw = SamplerV2(mode=backend)
sampler_hw.options.environment.job_tags = ["TUT_AITI"]

shots_hw = 500000
job_hw = sampler_hw.run([mirror_default_hw, mirror_ai_hw], shots=shots_hw)
print(f"Job submitted: {job_hw.job_id()}")

Mirror circuit (Default): depth 1577, gates 9672
Mirror circuit (AI):      depth 1235, gates 11092
Job submitted: d8gt7vm6983c73dqbg0g

# -------------------------Step 4-------------------------
result_hw = job_hw.result()

survival_probs_hw = {}
for i, method in enumerate(["Default", "AI"]):
    counts = result_hw[i].data.meas.get_counts()
    mirror = [mirror_default_hw, mirror_ai_hw][i]
    all_zeros = "0" * mirror.num_qubits
    survival = counts.get(all_zeros, 0) / shots_hw
    survival_probs_hw[method] = survival
    print(
        f"{method:8s}  P(|00...0>) = {survival:.4f}  ({counts.get(all_zeros, 0)}/{shots_hw})"
    )

# Plot 1 - P(|0...0>), the probability of an erroneous (non-zero) outcome.
# A lower bar means the transpilation introduced less noise.
error_probs_hw = {method: 1 - p for method, p in survival_probs_hw.items()}

fig, ax = plt.subplots(figsize=(6, 4))
ax.bar(
    error_probs_hw.keys(),
    error_probs_hw.values(),
    color=["steelblue", "coral"],
)
ax.set_ylabel("1 - P(|0...0>)")
ax.set_title(f"Mirror Circuit Error (26-qubit, {backend.name})")
ax.set_ylim(0, 1)
plt.tight_layout()
plt.show()

Default   P(|00...0>) = 0.0005  (239/500000)
AI        P(|00...0>) = 0.0050  (2516/500000)

Analisis hasil

Hasil skala besar memperkuat tren yang diamati pada contoh skala kecil, kini pada skala yang lebih menantang.

Two-qubit depth: Transpiler bertenaga AI terus menghasilkan two-qubit depth yang lebih rendah secara nyata di seluruh rentang ukuran Circuit. Optimasi depth adalah salah satu tujuan utama yang dilatih model routing AI, dan keunggulannya lebih terasa pada jumlah qubit yang lebih besar di mana masalah routing menjadi lebih sulit bagi metode heuristik.

Jumlah Gate: Transpiler default (SABRE) secara konsisten menghasilkan Circuit dengan lebih sedikit Gate di semua ukuran Circuit dalam rentang ini. Heuristik SABRE secara khusus dirancang untuk meminimalkan jumlah Gate, dan pada skala ini keunggulannya jelas dan seragam.

Waktu transpilasi: Kesenjangan waktu transpilasi semakin lebar pada skala yang lebih besar. SABRE tetap hampir konstan, sedangkan waktu proses Transpiler bertenaga AI tumbuh lebih curam. Meskipun begitu, waktu proses Transpiler bertenaga AI tetap praktis untuk sebagian besar alur kerja.

Fidelitas mirror circuit: Kedua metode menghasilkan probabilitas bertahan hidup yang jauh di bawah 1% pada skala ini, menyisakan sedikit sinyal yang dapat digunakan. Dengan total jumlah Gate sekitar 10.000 dan two-qubit depth melebihi 1.000, noise depolarizing yang terakumulasi di seluruh mirror circuit menghancurkan sebagian besar sinyal. Hal ini menyoroti keterbatasan utama pendekatan mirror circuit: meskipun sederhana dan tidak memerlukan simulasi klasik, ia tidak skalabel dengan baik untuk Circuit yang besar atau dalam, di mana kedua metode terdorong mendekati noise floor dan sinyal yang tersisa kecil didominasi oleh accumulated error.

Meskipun hasil ini menegaskan efektivitas Transpiler bertenaga AI, penting untuk dicatat keterbatasannya. Metode sintesis AI saat ini hanya tersedia untuk coupling map tertentu, yang dapat membatasi penerapannya secara lebih luas. Keterbatasan ini perlu dipertimbangkan saat mengevaluasi penggunaannya dalam skenario yang berbeda.

Langkah selanjutnya

Rekomendasi

Jika kamu tertarik dengan topik ini, kamu mungkin tertarik dengan materi berikut:

• Transpilation optimizations with SABRE
• Compilation methods for Hamiltonian simulation circuits