Pengenalan transpiler berkuasa AI Qiskit

Anggaran penggunaan: 5 minit pada IBM Heron (NOTA: Ini hanya anggaran sahaja. Masa jalan sebenar mungkin berbeza.)

Hasil pembelajaran

Selepas melalui tutorial ini, pengguna sepatutnya faham:

• Cara menggunakan transpiler berkuasa AI (generate_ai_pass_manager) sebagai pengganti langsung bagi transpiler standard
• Cara transpiler berkuasa AI berbanding dengan transpiler lalai dari segi kedalaman dua-Qubit, bilangan Gate, dan masa transpilasi
• Cara menggunakan litar cermin untuk menilai kualiti transpilasi melalui pelaksanaan perkakasan

Prasyarat

Kami cadangkan pengguna biasa dengan topik berikut sebelum melalui tutorial ini:

• Transpil litar
• Konfigurasi pengurus laluan pratakrif
• Laluan transpiler berkuasa AI

Latar belakang

Transpiler berkuasa AI Qiskit memperkenalkan laluan transpilasi berasaskan pembelajaran mesin yang boleh menghasilkan litar yang lebih pendek dan lebih cekap dari segi perkakasan berbanding kaedah heuristik tradisional seperti SABRE. Litar yang lebih pendek mengumpul lebih sedikit bunyi, yang secara langsung meningkatkan kualiti keputusan pada perkakasan kuantum sebenar.

Dalam tutorial ini kami membandingkan dua strategi transpilasi:

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

Kami mengukur tiga metrik bagi setiap strategi: kedalaman Gate dua-Qubit, jumlah bilangan Gate, dan masa jalan transpilasi.

Penanda aras transpiler berkuasa AI

Dalam ujian penanda aras, transpiler berkuasa AI secara konsisten menghasilkan litar yang lebih cetek dan berkualiti lebih tinggi berbanding transpiler Qiskit standard. Untuk ujian ini, kami menggunakan strategi pengurus laluan lalai Qiskit, yang dikonfigurasikan dengan generate_preset_pass_manager. Walaupun strategi lalai ini sering berkesan, ia boleh bergelut dengan litar yang lebih besar atau lebih kompleks. Sebaliknya, laluan berkuasa AI mencapai pengurangan purata 24% dalam bilangan Gate dua-Qubit dan pengurangan 36% dalam kedalaman litar untuk litar besar (100+ Qubit) semasa transpilasi ke topologi heavy-hex perkakasan IBM Quantum®. Untuk maklumat lanjut tentang penanda aras ini, rujuk blog ini.

Tutorial ini meneroka manfaat utama laluan AI dan cara ia berbanding dengan kaedah tradisional.

Keperluan

Sebelum memulakan tutorial ini, pastikan kamu telah memasang perkara berikut:

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

Persediaan

# 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 berskala kecil

Langkah 1: Petakan input klasik kepada masalah kuantum

Kami menjana 20 litar rawak dengan kedalaman 4, di mana bilangan Qubit berkisar dari enam hingga 25. Litar-litar ini akan menjadi kes ujian kami 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: Optimumkan masalah untuk pelaksanaan perkakasan kuantum

Kami membina pengurus laluan lalai (SABRE) untuk Backend yang dipilih. Kedua-dua strategi transpilasi menyasarkan peta gandingan penuh Backend. Simulasi tempatan kemudian kekal boleh urus kerana langkah simulasi menggunakan remap_to_contiguous untuk melabelkan semula setiap litar yang ditranspil ke atas hanya Qubit aktifnya, jadi Aer hanya mensimulasikan Qubit tersebut dan bukannya keseluruhan peranti.

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%

Jadual ringkasan menunjukkan min dan sisihan piawai bagi setiap metrik merentasi semua 20 litar, bersama dengan peratusan penambahbaikan purata transpiler berkuasa AI berbanding lalai. Nilai positif menunjukkan transpiler berkuasa AI menghasilkan keputusan yang lebih baik; nilai negatif menunjukkan lalai lebih baik.

Untuk contoh berskala kecil ini, transpiler berkuasa AI mencapai kedalaman dua-Qubit yang lebih rendah kira-kira 16% secara purata, tetapi dengan kos bilangan Gate yang lebih tinggi kira-kira 9%. Ini menonjolkan pertukaran utama apabila memilih antara dua strategi: transpiler berkuasa AI mengutamakan pengurangan kedalaman (lebih sedikit lapisan berturutan Gate dua-Qubit), manakala transpiler lalai (SABRE) mengutamakan meminimumkan jumlah bilangan Gate (lebih sedikit sisipan SWAP). Bergantung pada aplikasi kamu, satu metrik mungkin lebih penting berbanding yang lain.

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

Kedalaman dua-Qubit: Transpiler berkuasa AI umumnya menghasilkan litar dengan kedalaman dua-Qubit yang lebih rendah. Kedalaman adalah salah satu metrik utama yang model routing AI dilatih untuk optimumkan, dan penambahbaikan kelihatan merentasi kebanyakan saiz litar, walaupun SABRE memadankan atau mengatasinya pada litar individu.

Bilangan Gate: Keputusan sangat hampir pada skala ini, dengan SABRE mempunyai sedikit kelebihan keseluruhan. Heuristik routing SABRE direka untuk meminimumkan bilangan Gate SWAP yang disisipkan, yang secara langsung mengurangkan bilangan Gate. Pada saiz litar yang kecil, perbezaannya adalah sederhana.

Masa transpilasi: Masa jalan SABRE hampir malar tanpa mengira bilangan Qubit, jadi saiz litar mempunyai sedikit kesan pada masa transpilasi pada skala ini. Logik routing teras SABRE sangat dioptimumkan (sebahagian besarnya dilaksanakan dalam Rust). Transpiler berkuasa AI mengambil masa yang ketara lebih lama dan berskala dengan saiz litar, walaupun masa mutlak kekal munasabah untuk penggunaan interaktif.

Langkah 3: Laksanakan menggunakan primitif Qiskit

Untuk menilai kesan transpilasi pada kesetiaan litar, bina litar cermin dari kes 10-Qubit dan jalankan pada simulator Aer dengan model bunyi yang mudah. Output yang dijangka bagi litar cermin sentiasa rentetan bit semua-sifar, jadi kebarangkalian mengukur $|0\rangle^{\otimes n}$ menunjukkan betapa baiknya setiap strategi transpilasi memelihara kesetiaan.

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

Kami menjalankan kedua-dua litar cermin melalui simulator Aer dengan model bunyi depolarizing yang mudah. Kebarangkalian kelangsungan, ditakrifkan sebagai pecahan tembakan yang mengembalikan rentetan bit semua-sifar, mengukur berapa banyak bunyi yang diperkenalkan oleh setiap strategi transpilasi.

Langkah 4: Pasca-proses dan kembalikan hasil dalam format klasik yang dikehendaki

Kami mengekstrak kebarangkalian mengukur rentetan bit semua-sifar dari kedua-dua jalan. Kebarangkalian kelangsungan yang lebih tinggi menunjukkan kesetiaan yang lebih baik, bermakna transpilasi memperkenalkan lebih sedikit bunyi. Plot di bawah menunjukkan pelengkap, 1 - P(|0...0>), supaya bar yang lebih rendah menunjukkan kesetiaan yang lebih baik dan perbezaan kecil dalam ralat 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 kes ini, transpiler lalai menghasilkan litar yang lebih cetek dan lebih kecil untuk instans 10-Qubit tertentu ini, jadi kesetiaan yang lebih tinggi adalah dijangkakan. Keputusan per-litar berbeza-beza: seperti yang ditunjukkan jadual ringkasan di atas, kelebihan transpiler berkuasa AI adalah dalam kedalaman dua-Qubit yang lebih rendah secara purata, bukan pada setiap litar individu. Strategi mana yang menghasilkan kesetiaan yang lebih tinggi bergantung pada magnitud perbezaan dalam setiap metrik, ciri-ciri bunyi perkakasan, dan struktur litar. Di bawah model bunyi depolarizing yang seragam, jumlah bilangan Gate sering mempunyai kesan yang lebih langsung pada ralat terkumpul berbanding kedalaman sahaja.

Contoh perkakasan berskala besar

Langkah 1-4

Di sini semua butiran ini digabungkan menjadi aliran kerja yang jelas pada skala yang lebih besar, yang kemudian dijalankan pada perkakasan kuantum sebenar.

Kod di bawah menjana 25 litar rawak dengan kedalaman 8, di mana bilangan Qubit berkisar dari 26 hingga 50. Litar-litar ini kemudian ditranspil dengan kedua-dua strategi dan metrik yang sama dikumpulkan. Kemudian kami membina litar cermin dari kes 26-Qubit dan menghantarnya ke Backend sebenar.

# -------------------------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 keputusan

Keputusan berskala besar menguatkan trend yang diperhatikan dalam contoh berskala kecil, kini pada skala yang lebih mencabar.

Kedalaman dua-Qubit: Transpiler berkuasa AI terus memberikan kedalaman dua-Qubit yang ketara lebih rendah merentasi julat penuh saiz litar. Pengoptimuman kedalaman adalah salah satu objektif utama yang model routing AI dilatih untuk capai, dan kelebihan lebih ketara pada bilangan Qubit yang lebih besar di mana masalah routing menjadi lebih sukar untuk kaedah heuristik.

Bilangan Gate: Transpiler lalai (SABRE) secara konsisten menghasilkan litar dengan Gate yang lebih sedikit merentasi semua saiz litar dalam julat ini. Heuristik SABRE direka khusus untuk meminimumkan bilangan Gate, dan pada skala ini kelebihan tersebut jelas dan seragam.

Masa transpilasi: Jurang dalam masa transpilasi melebar pada skala yang lebih besar. SABRE kekal hampir malar, manakala masa jalan transpiler berkuasa AI berkembang lebih curam. Walaupun begitu, masa jalan transpiler berkuasa AI kekal praktikal untuk kebanyakan aliran kerja.

Kesetiaan litar cermin: Kedua-dua kaedah menghasilkan kebarangkalian kelangsungan jauh di bawah 1% pada skala ini, meninggalkan sedikit isyarat yang boleh digunakan. Dengan jumlah bilangan Gate sekitar 10,000 dan kedalaman dua-Qubit melebihi 1,000, bunyi depolarizing yang terkumpul merentasi litar cermin mengatasi kebanyakan isyarat. Ini menonjolkan had utama pendekatan litar cermin: walaupun ia mudah dan tidak memerlukan simulasi klasik, ia tidak berskala dengan baik untuk litar yang besar atau dalam, di mana kedua-dua kaedah didorong hampir ke ambang bunyi dan isyarat kecil yang bertahan didominasi oleh ralat terkumpul.

Walaupun keputusan ini menekankan keberkesanan transpiler berkuasa AI, penting untuk ambil perhatian tentang hadnya. Kaedah sintesis AI pada masa ini hanya tersedia untuk peta gandingan tertentu, yang mungkin mengehadkan kebolehgunaannya yang lebih luas. Kekangan ini perlu dipertimbangkan apabila menilai penggunaannya dalam senario yang berbeza.

Langkah seterusnya

Cadangan

Jika kamu mendapati hasil kerja ini menarik, kamu mungkin berminat dengan bahan berikut:

• Pengoptimuman transpilasi dengan SABRE
• Kaedah penyusunan untuk litar simulasi Hamiltonian