Pengenalan perkhidmatan transpiler berkuasa AI Qiskit

Anggaran penggunaan QPU: Tiada (NOTA: Tutorial ini tidak melaksanakan kerja kerana ia memfokuskan pada transpilasi)

Latar belakang

Perkhidmatan transpiler berkuasa AI Qiskit (QTS) memperkenalkan pengoptimuman berasaskan pembelajaran mesin dalam laluan routing dan sintesis. Mod AI ini direka untuk mengatasi had transpilasi tradisional, khususnya untuk litar berskala besar dan topologi perkakasan yang kompleks.

Mulai Julai 2025, Perkhidmatan Transpiler telah dipindahkan ke Platform IBM Quantum® baharu dan tidak lagi tersedia. Untuk kemas kini terkini tentang status Perkhidmatan Transpiler, sila rujuk dokumentasi perkhidmatan transpiler. Kamu masih boleh menggunakan transpiler AI secara tempatan, serupa dengan transpilasi Qiskit standard. Cuma gantikan generate_preset_pass_manager() dengan generate_ai_pass_manager(). Fungsi ini membina pengurus laluan yang mengintegrasikan laluan routing dan sintesis berkuasa AI terus ke dalam aliran kerja transpilasi tempatan kamu.

Ciri-ciri utama laluan AI

• Laluan routing: Routing berkuasa AI boleh menyesuaikan laluan qubit secara dinamik berdasarkan litar dan Backend tertentu, mengurangkan keperluan Gate SWAP yang berlebihan.

  • AIRouting: Pemilihan susun atur dan routing litar

• Laluan sintesis: Teknik AI mengoptimumkan penguraian Gate berbilang qubit, meminimumkan bilangan Gate dua-qubit yang lazimnya lebih terdedah kepada ralat.

  • AICliffordSynthesis: Sintesis Gate Clifford
  • AILinearFunctionSynthesis: Sintesis litar fungsi linear
  • AIPermutationSynthesis: Sintesis litar permutasi
  • AIPauliNetworkSynthesis: Sintesis litar Jaringan Pauli (hanya tersedia dalam Perkhidmatan Transpiler Qiskit, tidak dalam persekitaran tempatan)

• Perbandingan dengan transpilasi tradisional: Transpiler Qiskit standard ialah alat yang kukuh dan boleh mengendalikan pelbagai litar kuantum dengan berkesan. Namun, apabila litar semakin besar atau konfigurasi perkakasan menjadi lebih kompleks, laluan AI boleh memberikan keuntungan pengoptimuman tambahan. Dengan menggunakan model pembelajaran untuk routing dan sintesis, QTS memperhalusi lagi susun atur litar dan mengurangkan overhed untuk tugasan kuantum yang mencabar atau berskala besar.

Tutorial ini menilai mod AI menggunakan laluan routing dan sintesis, membandingkan hasilnya dengan transpilasi tradisional untuk menyerlahkan di mana AI menawarkan peningkatan prestasi.

Untuk maklumat lanjut tentang laluan AI yang tersedia, lihat dokumentasi laluan AI.

Kenapa guna AI untuk transpilasi litar kuantum?

Apabila litar kuantum semakin besar dan kompleks, kaedah transpilasi tradisional sukar untuk mengoptimumkan susun atur dan mengurangkan bilangan Gate dengan cekap. Litar yang lebih besar, terutamanya yang melibatkan ratusan qubit, menimbulkan cabaran ketara dalam routing dan sintesis akibat kekangan peranti, sambungan terhad, dan kadar ralat qubit.

Di sinilah transpilasi berkuasa AI menawarkan penyelesaian yang berpotensi. Dengan memanfaatkan teknik pembelajaran mesin, transpiler berkuasa AI dalam Qiskit boleh membuat keputusan yang lebih bijak tentang routing qubit dan sintesis Gate, menghasilkan pengoptimuman litar kuantum berskala besar yang lebih baik.

Ringkasan hasil penanda aras

Dalam ujian penanda aras, transpiler AI secara konsisten menghasilkan litar yang lebih cetek dan berkualiti tinggi berbanding transpiler Qiskit standard. Untuk ujian ini, kami menggunakan strategi pengurus laluan lalai Qiskit, yang dikonfigurasikan dengan [generate_preset_passmanager]. 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.

# 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

Keperluan

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

• Qiskit SDK v1.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]')

Persediaan

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)

Bahagian I. Corak Qiskit

Mari kita lihat cara menggunakan perkhidmatan transpiler AI dengan litar kuantum yang mudah, menggunakan corak Qiskit. Kuncinya ialah mencipta PassManager dengan generate_ai_pass_manager() sebagai ganti generate_preset_pass_manager() yang standard.

Langkah 1: Petakan input klasik kepada masalah kuantum

Dalam bahagian ini, kita akan menguji transpiler AI pada litar efficient_su2, iaitu ansatz cekap perkakasan yang digunakan secara meluas. Litar ini amat relevan untuk algoritma kuantum variasi (contohnya, VQE) dan tugasan pembelajaran mesin kuantum, menjadikannya kes ujian yang ideal untuk menilai prestasi transpilasi.

Litar efficient_su2 terdiri daripada lapisan berselang-seli putaran qubit tunggal dan Gate membelit seperti CNOT. Lapisan-lapisan ini membolehkan penerokaan ruang keadaan kuantum yang fleksibel sambil memastikan kedalaman Gate dapat diurus. Dengan mengoptimumkan litar ini, kita bertujuan untuk mengurangkan bilangan Gate, meningkatkan ketepatan, dan meminimumkan bunyi. Ini menjadikannya calon yang kuat untuk menguji kecekapan transpiler 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")

Langkah 2: Optimumkan masalah untuk pelaksanaan perkakasan kuantum

Pilih Backend

Untuk contoh ini, kita pilih Backend operasi IBM Quantum yang paling kurang sibuk, bukan simulator, dan mempunyai sekurang-kurangnya 100 qubit:

Nota: Memandangkan Backend yang paling kurang sibuk boleh berubah mengikut masa, peranti yang berbeza mungkin dipilih untuk setiap jalan. Sifat khusus peranti, seperti peta gandingan, boleh menyebabkan perbezaan dalam litar yang ditranspilasikan.

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

Cipta pengurus laluan AI dan tradisional

Untuk menilai keberkesanan transpiler AI, kita akan melakukan dua jalan transpilasi. Pertama, kita akan transpilasikan litar menggunakan transpiler AI. Kemudian, kita akan buat perbandingan dengan mentranspilasikan litar yang sama tanpa transpiler AI, menggunakan kaedah tradisional. Kedua-dua proses transpilasi akan menggunakan peta gandingan yang sama dari Backend yang dipilih dan tahap pengoptimuman ditetapkan kepada 3 untuk perbandingan yang adil.

Kedua-dua kaedah ini mencerminkan pendekatan standard untuk mencipta instans PassManager bagi mentranspilasikan litar dalam 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
)

Transpilasikan litar dan rekodkan masanya.

# 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

Dalam ujian ini, kita membandingkan prestasi transpiler AI dan kaedah transpilasi standard pada litar efficient_su2. Transpiler AI mencapai kedalaman litar yang ketara lebih cetek sambil mengekalkan bilangan Gate yang serupa.

• Kedalaman litar: Transpiler AI menghasilkan litar dengan kedalaman dua-qubit yang lebih rendah. Ini dijangka, kerana laluan AI dilatih untuk mengoptimumkan kedalaman dengan mempelajari corak interaksi qubit dan mengeksploitasi sambungan perkakasan dengan lebih berkesan berbanding heuristik berasaskan peraturan.

• Bilangan Gate: Jumlah bilangan Gate kekal serupa antara kedua-dua kaedah. Ini selaras dengan jangkaan kerana transpilasi berasaskan SABRE standard secara eksplisit meminimumkan bilangan swap, yang mendominasi overhed Gate. Transpiler AI sebaliknya mengutamakan kedalaman keseluruhan dan mungkin sesekali menukar beberapa Gate tambahan untuk laluan pelaksanaan yang lebih pendek.

• Masa transpilasi: Transpiler AI mengambil masa lebih lama untuk dijalankan berbanding kaedah standard. Ini disebabkan oleh kos pengkomputeran tambahan untuk memanggil model yang dipelajari semasa routing dan sintesis. Sebaliknya, transpiler berasaskan SABRE kini jauh lebih pantas setelah ditulis semula dan dioptimumkan dalam Rust, menyediakan routing heuristik yang sangat cekap pada skala besar.

Penting untuk diambil perhatian bahawa keputusan ini berdasarkan hanya satu litar. Untuk mendapatkan pemahaman yang komprehensif tentang cara transpiler AI berbanding dengan kaedah tradisional, perlu menguji pelbagai jenis litar. Prestasi QTS boleh berbeza-beza bergantung pada jenis litar yang dioptimumkan. Untuk perbandingan yang lebih luas, rujuk penanda aras di atas atau lawati blog tersebut.

Langkah 3: Laksanakan menggunakan primitif Qiskit

Memandangkan tutorial ini memberi tumpuan kepada transpilasi, tiada eksperimen yang akan dilaksanakan pada peranti kuantum. Matlamatnya adalah untuk memanfaatkan pengoptimuman dari Langkah 2 bagi mendapatkan litar yang ditranspilasikan dengan kedalaman atau bilangan Gate yang berkurangan.

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

Memandangkan tiada pelaksanaan untuk notebook ini, tiada hasil untuk diproses selepas ini.

Bahagian II. Analisis dan penanda aras litar yang ditranspilasikan

Dalam bahagian ini, kita akan tunjukkan cara menganalisis litar yang ditranspilasikan dan menanda arasnya berbanding versi asal dengan lebih terperinci. Kita akan fokus pada metrik seperti kedalaman litar, bilangan Gate, dan masa transpilasi untuk menilai keberkesanan pengoptimuman. Di samping itu, kita akan bincangkan cara keputusan mungkin berbeza merentasi pelbagai jenis litar, memberikan pandangan tentang prestasi transpiler yang lebih luas merentasi senario berbeza.

# 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

Purata peratusan pengurangan bagi setiap metrik. Positif bermakna penambahbaikan, negatif bermakna kemerosotan.

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

Prestasi transpiler AI berbeza-beza dengan ketara bergantung pada jenis litar yang dioptimumkan. Dalam sesetengah kes, ia mencapai pengurangan ketara dalam kedalaman litar dan bilangan Gate berbanding transpiler standard. Walau bagaimanapun, penambahbaikan ini sering datang dengan peningkatan masa jalan yang ketara.

Untuk jenis litar tertentu, transpiler AI mungkin menghasilkan keputusan yang sedikit lebih baik dari segi kedalaman litar tetapi juga boleh menyebabkan peningkatan bilangan Gate dan penalti masa jalan yang ketara. Pemerhatian ini menunjukkan bahawa manfaat transpiler AI tidak seragam merentasi semua jenis litar. Sebaliknya, keberkesanannya bergantung pada ciri-ciri khusus litar, menjadikannya lebih sesuai untuk sesetengah kes penggunaan berbanding yang lain.

Bila pengguna patut pilih transpilasi berkuasa AI?

Transpiler berkuasa AI dalam Qiskit sangat bagus dalam senario di mana kaedah transpilasi tradisional sukar berfungsi, terutamanya untuk litar kuantum berskala besar dan kompleks. Untuk litar yang melibatkan ratusan Qubit atau yang menyasarkan perkakasan dengan peta gandingan yang rumit, Transpiler AI menawarkan pengoptimuman yang lebih baik dari segi kedalaman litar, bilangan Gate, dan kecekapan masa jalan. Dalam ujian penanda aras, ia secara konsisten mengatasi kaedah tradisional, menghasilkan litar yang jauh lebih cetek dan mengurangkan bilangan Gate, yang penting untuk meningkatkan prestasi dan mengurangkan hingar pada perkakasan kuantum sebenar.

Pengguna patut mempertimbangkan transpilasi berkuasa AI apabila bekerja dengan:

• Litar besar di mana kaedah tradisional gagal mengendalikan skala dengan cekap.
• Topologi perkakasan yang kompleks di mana cabarannya adalah sambungan peranti dan penghalaan.
• Aplikasi sensitif prestasi di mana mengurangkan kedalaman litar dan meningkatkan ketepatan adalah sangat penting.

Bahagian III. Terokai sintesis rangkaian permutasi berkuasa AI

Rangkaian permutasi adalah asas dalam pengkomputeran kuantum, terutamanya untuk sistem yang terkekang oleh topologi terhad. Rangkaian ini memudahkan interaksi jarak jauh dengan menukar Qubit secara dinamik untuk meniru sambungan semua-ke-semua pada perkakasan dengan sambungan terhad. Transformasi sedemikian penting untuk melaksanakan algoritma kuantum yang kompleks pada peranti jangka terdekat, di mana interaksi sering merentasi lebih jauh daripada jiran terdekat.

Dalam bahagian ini, kami mengetengahkan sintesis rangkaian permutasi sebagai kes penggunaan yang menarik untuk Transpiler berkuasa AI dalam Qiskit. Secara khusus, pas AIPermutationSynthesis memanfaatkan pengoptimuman berasaskan AI untuk menghasilkan litar yang cekap bagi tugas permutasi Qubit. Sebaliknya, pendekatan sintesis generik sering sukar untuk mengimbangi bilangan Gate dan kedalaman litar, terutamanya dalam senario dengan interaksi Qubit yang padat atau apabila cuba mencapai sambungan penuh.

Kami akan membimbing anda melalui contoh corak Qiskit yang mempamerkan sintesis rangkaian permutasi untuk mencapai sambungan semua-ke-semua bagi satu set Qubit. Kami akan membandingkan prestasi AIPermutationSynthesis dengan kaedah sintesis standard dalam Qiskit. Contoh ini akan menunjukkan bagaimana Transpiler AI mengoptimumkan untuk kedalaman litar dan bilangan Gate yang lebih rendah, menonjolkan kelebihannya dalam aliran kerja kuantum praktikal. Untuk mengaktifkan pas sintesis AI, kami akan menggunakan fungsi generate_ai_pass_manager() dengan parameter include_ai_synthesis ditetapkan kepada True.

Langkah 1: Petakan input klasik kepada masalah kuantum

Untuk mewakili masalah permutasi klasik pada komputer kuantum, kita mulakan dengan menentukan struktur litar kuantum. Untuk contoh ini:

1. Permulaan Circuit kuantum: Kami memperuntukkan 27 Qubit untuk sepadan dengan Backend yang akan kami gunakan, yang mempunyai 27 Qubit.

2. Gunakan permutasi: Kami menjana sepuluh corak permutasi rawak (pattern_1 hingga pattern_10) menggunakan benih tetap untuk kebolehulangan. Setiap corak permutasi digunakan pada Circuit kuantum yang berasingan (qc_1 hingga qc_10).

3. Penguraian Circuit: Setiap operasi permutasi diuraikan kepada set gate natif yang serasi dengan perkakasan kuantum sasaran. Kami menganalisis kedalaman dan bilangan gate dua-Qubit (gate bukan setempat) untuk setiap litar yang diuraikan.

Hasilnya memberikan gambaran tentang kerumitan mewakili masalah permutasi klasik pada peranti kuantum, menunjukkan keperluan sumber untuk corak permutasi yang berbeza.

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

Langkah 2: Optimumkan masalah untuk pelaksanaan perkakasan kuantum

Dalam langkah ini, kami meneruskan pengoptimuman menggunakan pas sintesis AI.

Untuk pas sintesis AI, PassManager hanya memerlukan peta gandingan Backend. Walau bagaimanapun, penting untuk diingat bahawa tidak semua peta gandingan serasi; hanya peta yang telah dilatih oleh pas AIPermutationSynthesis yang akan berfungsi. Pada masa ini, pas AIPermutationSynthesis menyokong blok bersaiz 65, 33, dan 27 Qubit. Untuk contoh ini kami menggunakan QPU 27-Qubit.

Untuk perbandingan, kami akan menilai prestasi sintesis AI berbanding kaedah sintesis permutasi generik dalam Qiskit, termasuk:

• synth_permutation_depth_lnn_kms: Kaedah ini mensintesis litar permutasi untuk seni bina jiran terdekat linear (LNN) menggunakan algoritma Kutin, Moulton, dan Smithline (KMS). Ia menjamin litar dengan kedalaman paling banyak $n$ dan saiz paling banyak $n(n-1)/2$, di mana kedua-dua kedalaman dan saiz diukur dari segi Gate SWAP.

• synth_permutation_basic: Ini adalah pelaksanaan mudah yang mensintesis litar permutasi tanpa mengenakan kekangan pada sambungan atau pengoptimuman untuk seni bina tertentu. Ia berfungsi sebagai garis asas untuk membandingkan prestasi dengan kaedah yang lebih canggih.

Setiap kaedah ini mewakili pendekatan tersendiri untuk mensintesis rangkaian permutasi, memberikan penanda aras yang komprehensif berbanding kaedah berkuasa AI.

Untuk maklumat lanjut tentang kaedah sintesis dalam Qiskit, rujuk dokumentasi API Qiskit. Tentukan peta gandingan yang mewakili QPU 27-Qubit.

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

Transpil setiap litar permutasi menggunakan pas sintesis AI dan kaedah sintesis generik.

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)

Rekod metrik (kedalaman, bilangan gate, masa) untuk setiap litar selepas transpilasi.

# 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

Hasilnya menunjukkan bahawa Transpiler AI mengatasi semua kaedah sintesis Qiskit lain untuk set litar permutasi rawak ini. Penemuan utama termasuk:

1. Kedalaman: Transpiler AI mencapai kedalaman purata yang paling rendah, menunjukkan pengoptimuman susun atur litar yang lebih baik.
2. Bilangan Gate: Ia mengurangkan bilangan Gate dengan ketara berbanding kaedah lain, meningkatkan ketepatan dan kecekapan pelaksanaan.
3. Masa transpilasi: Semua kaedah berjalan dengan sangat cepat pada skala ini, menjadikannya praktikal untuk digunakan. Walau bagaimanapun, Transpiler AI mempunyai peningkatan masa jalan yang ketara berbanding kaedah tradisional disebabkan oleh kerumitan model AI yang digunakan.

Keputusan ini menetapkan Transpiler AI sebagai pendekatan yang paling berkesan untuk penanda aras ini, terutamanya untuk pengoptimuman kedalaman dan bilangan Gate. Plot hasilnya untuk membandingkan prestasi pas sintesis AI berbanding kaedah sintesis generik.

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

Graf ini menonjolkan keputusan individu untuk setiap litar (qc_1 hingga qc_10) merentasi kaedah sintesis yang berbeza:

Walaupun keputusan ini menegaskan keberkesanan Transpiler AI untuk litar permutasi, penting untuk ambil perhatian tentang batasannya. 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.

Secara keseluruhannya, Transpiler AI menunjukkan peningkatan yang menjanjikan dalam pengoptimuman kedalaman dan bilangan Gate untuk litar-litar khusus ini sambil mengekalkan masa transpilasi yang setanding.

Langkah 3: Laksanakan menggunakan primitif Qiskit

Memandangkan tutorial ini memberi tumpuan kepada transpilasi, tiada eksperimen yang akan dilaksanakan pada peranti kuantum. Matlamatnya adalah untuk memanfaatkan pengoptimuman dari Langkah 2 untuk mendapatkan litar yang telah ditranspil dengan kedalaman atau bilangan Gate yang lebih rendah.

Langkah 4: Proses selepas dan kembalikan keputusan dalam format klasik yang dikehendaki

Memandangkan tiada pelaksanaan untuk notebook ini, tiada keputusan untuk diproses selepasnya.

Kaji selidik tutorial

Sila ambil kaji selidik ringkas ini untuk memberikan maklum balas tentang tutorial ini. Pandangan anda akan membantu kami menambah baik kandungan dan pengalaman pengguna kami.

Link to survey

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.