Pengenalan layanan transpiler bertenaga AI Qiskit

Perkiraan penggunaan QPU: Tidak ada (CATATAN: Tutorial ini tidak menjalankan job karena berfokus pada transpilasi)

Latar Belakang

Layanan transpiler bertenaga AI Qiskit (QTS) memperkenalkan optimasi berbasis machine learning pada pass routing maupun synthesis. Mode AI ini dirancang untuk mengatasi keterbatasan transpilasi tradisional, khususnya untuk sirkuit berskala besar dan topologi hardware yang kompleks.

Per Juli 2025, Transpiler Service telah dimigrasikan ke IBM Quantum® Platform yang baru dan tidak lagi tersedia. Untuk pembaruan terkini tentang status Transpiler Service, silakan lihat dokumentasi transpiler service. Kamu masih bisa menggunakan transpiler AI secara lokal, mirip seperti transpilasi Qiskit standar. Cukup ganti generate_preset_pass_manager() dengan generate_ai_pass_manager(). Fungsi ini membangun pass manager yang mengintegrasikan pass routing dan synthesis bertenaga AI langsung ke dalam alur transpilasi lokalmu.

Fitur utama AI passes

• Pass routing: Routing bertenaga AI dapat menyesuaikan jalur Qubit secara dinamis berdasarkan Circuit dan Backend tertentu, mengurangi kebutuhan akan Gate SWAP yang berlebihan.

  • AIRouting: Pemilihan layout dan routing Circuit

• Pass synthesis: Teknik AI mengoptimalkan dekomposisi Gate multi-Qubit, meminimalkan jumlah Gate dua-Qubit yang biasanya lebih rentan terhadap error.

  • AICliffordSynthesis: Synthesis Gate Clifford
  • AILinearFunctionSynthesis: Synthesis Circuit fungsi linear
  • AIPermutationSynthesis: Synthesis Circuit permutasi
  • AIPauliNetworkSynthesis: Synthesis Circuit Pauli Network (hanya tersedia di Qiskit Transpiler Service, tidak di lingkungan lokal)

• Perbandingan dengan transpilasi tradisional: Transpiler Qiskit standar adalah alat yang andal dan dapat menangani berbagai spektrum Circuit kuantum secara efektif. Namun, ketika Circuit semakin besar skalanya atau konfigurasi hardware semakin kompleks, AI passes dapat memberikan keuntungan optimasi tambahan. Dengan menggunakan model yang sudah dipelajari untuk routing dan synthesis, QTS lebih lanjut menyempurnakan layout Circuit dan mengurangi overhead untuk tugas kuantum yang menantang atau berskala besar.

Tutorial ini mengevaluasi mode AI menggunakan pass routing maupun synthesis, membandingkan hasilnya dengan transpilasi tradisional untuk menyoroti di mana AI memberikan peningkatan performa.

Untuk detail lebih lanjut tentang AI passes yang tersedia, lihat dokumentasi AI passes.

Mengapa menggunakan AI untuk transpilasi Circuit kuantum?

Seiring Circuit kuantum semakin besar dan kompleks, metode transpilasi tradisional kesulitan mengoptimalkan layout dan mengurangi jumlah Gate secara efisien. Circuit yang lebih besar, khususnya yang melibatkan ratusan Qubit, menimbulkan tantangan signifikan pada routing dan synthesis akibat keterbatasan perangkat, konektivitas terbatas, dan tingkat error Qubit.

Di sinilah transpilasi bertenaga AI menawarkan solusi potensial. Dengan memanfaatkan teknik machine learning, transpiler bertenaga AI di Qiskit dapat membuat keputusan yang lebih cerdas tentang routing Qubit dan synthesis Gate, menghasilkan optimasi yang lebih baik untuk Circuit kuantum berskala besar.

Ringkasan hasil benchmarking

Dalam pengujian benchmarking, transpiler 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_passmanager]. 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 benchmarking ini, lihat blog ini.

Tutorial ini mengeksplorasi manfaat utama AI passes dan cara perbandingannya dengan metode 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

Persyaratan

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

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

Pengaturan

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)

Bagian I. Pola Qiskit

Sekarang mari kita lihat bagaimana menggunakan layanan transpiler AI dengan Circuit kuantum sederhana, menggunakan pola Qiskit. Kuncinya adalah membuat PassManager dengan generate_ai_pass_manager() alih-alih generate_preset_pass_manager() yang standar.

Langkah 1: Petakan input klasik ke masalah kuantum

Di bagian ini, kita akan menguji transpiler AI pada Circuit efficient_su2, sebuah ansatz hardware-efficient yang banyak digunakan. Circuit ini sangat relevan untuk algoritma kuantum variasional (misalnya, VQE) dan tugas machine learning kuantum, menjadikannya kasus uji yang ideal untuk menilai performa transpilasi.

Circuit efficient_su2 terdiri dari lapisan bergantian antara rotasi Qubit tunggal dan Gate entangling seperti CNOT. Lapisan-lapisan ini memungkinkan eksplorasi ruang keadaan kuantum yang fleksibel sambil menjaga kedalaman Gate tetap terkendali. Dengan mengoptimalkan Circuit ini, kita bertujuan untuk mengurangi jumlah Gate, meningkatkan fidelitas, dan meminimalkan noise. Ini menjadikannya kandidat yang kuat untuk menguji efisiensi 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: Optimalkan masalah untuk eksekusi hardware kuantum

Pilih Backend

Untuk contoh ini, kita pilih Backend IBM Quantum yang paling tidak sibuk, bukan simulator, dan memiliki setidaknya 100 Qubit:

Catatan: Karena Backend yang paling tidak sibuk bisa berubah seiring waktu, perangkat yang berbeda mungkin dipilih untuk run yang berbeda. Properti spesifik perangkat, seperti coupling map, dapat menyebabkan perbedaan pada Circuit yang telah ditranspilasi.

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

Buat pass manager AI dan tradisional

Untuk mengevaluasi efektivitas transpiler AI, kita akan melakukan dua run transpilasi. Pertama, kita akan mentranspilasi Circuit menggunakan transpiler AI. Kemudian, kita akan menjalankan perbandingan dengan mentranspilasi Circuit yang sama tanpa transpiler AI, menggunakan metode tradisional. Kedua proses transpilasi akan menggunakan coupling map yang sama dari Backend yang dipilih dan level optimasi yang diatur ke 3 untuk perbandingan yang adil.

Kedua metode ini mencerminkan pendekatan standar untuk membuat instance PassManager guna mentranspilasi Circuit di 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
)

Transpilasi Circuit dan catat waktunya.

# 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 pengujian ini, kita membandingkan performa transpiler AI dan metode transpilasi standar pada Circuit efficient_su2. Transpiler AI menghasilkan kedalaman Circuit yang jauh lebih dangkal sambil mempertahankan jumlah Gate yang serupa.

• Kedalaman Circuit: Transpiler AI menghasilkan Circuit dengan kedalaman dua-Qubit yang lebih rendah. Hal ini diharapkan, karena pass AI dilatih untuk mengoptimalkan kedalaman dengan mempelajari pola interaksi Qubit dan memanfaatkan konektivitas hardware secara lebih efektif dibandingkan heuristik berbasis aturan.

• Jumlah Gate: Total jumlah Gate tetap serupa antara kedua metode. Ini sesuai dengan ekspektasi karena transpilasi berbasis SABRE standar secara eksplisit meminimalkan jumlah swap, yang mendominasi overhead Gate. Transpiler AI sebaliknya memprioritaskan kedalaman keseluruhan dan terkadang bisa menukar beberapa Gate tambahan untuk jalur eksekusi yang lebih pendek.

• Waktu transpilasi: Transpiler AI memerlukan waktu lebih lama untuk berjalan dibandingkan metode standar. Ini karena biaya komputasi tambahan dari pemanggilan model yang sudah dipelajari selama routing dan synthesis. Sebaliknya, transpiler berbasis SABRE kini jauh lebih cepat setelah ditulis ulang dan dioptimalkan dalam Rust, memberikan routing heuristik yang sangat efisien pada skala besar.

Penting untuk dicatat bahwa hasil ini hanya berdasarkan satu Circuit. Untuk mendapatkan pemahaman komprehensif tentang bagaimana transpiler AI dibandingkan dengan metode tradisional, perlu dilakukan pengujian pada berbagai Circuit. Performa QTS dapat sangat bervariasi tergantung pada jenis Circuit yang dioptimalkan. Untuk perbandingan yang lebih luas, lihat benchmarking di atas atau kunjungi blog ini.

Langkah 3: Eksekusi menggunakan Qiskit primitives

Karena tutorial ini berfokus pada transpilasi, tidak ada eksperimen yang akan dijalankan pada perangkat kuantum. Tujuannya adalah memanfaatkan optimasi dari Langkah 2 untuk mendapatkan Circuit yang telah ditranspilasi dengan kedalaman atau jumlah Gate yang berkurang.

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

Karena tidak ada eksekusi untuk notebook ini, tidak ada hasil yang perlu diproses.

Bagian II. Analisis dan benchmarking Circuit yang telah ditranspilasi

Di bagian ini, kita akan menunjukkan cara menganalisis Circuit yang telah ditranspilasi dan membandingkannya dengan versi asli secara lebih detail. Kita akan fokus pada metrik seperti kedalaman Circuit, jumlah Gate, dan waktu transpilasi untuk menilai efektivitas optimasi. Selain itu, kita akan membahas bagaimana hasil bisa berbeda di berbagai jenis Circuit, memberikan wawasan tentang performa transpiler yang lebih luas di berbagai skenario.

# 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

Rata-rata persentase pengurangan untuk setiap metrik. Positif berarti peningkatan, negatif berarti penurunan.

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

Performa transpiler AI bervariasi secara signifikan berdasarkan jenis Circuit yang dioptimalkan. Dalam beberapa kasus, ia mencapai pengurangan yang nyata dalam kedalaman Circuit dan jumlah Gate dibandingkan dengan transpiler standar. Namun, peningkatan ini sering kali disertai dengan peningkatan waktu proses yang substansial.

Untuk jenis Circuit tertentu, transpiler AI mungkin menghasilkan hasil yang sedikit lebih baik dalam hal kedalaman Circuit tetapi juga bisa menyebabkan peningkatan jumlah Gate dan penalti waktu proses yang signifikan. Pengamatan ini menunjukkan bahwa manfaat transpiler AI tidak seragam di semua jenis Circuit. Sebaliknya, efektivitasnya bergantung pada karakteristik spesifik Circuit, membuatnya lebih cocok untuk beberapa kasus penggunaan daripada yang lain.

Kapan pengguna sebaiknya memilih transpilasi berbasis AI?

Transpiler berbasis AI di Qiskit unggul dalam skenario di mana metode transpilasi tradisional kesulitan, terutama untuk Circuit berukuran besar dan kompleks. Untuk Circuit yang melibatkan ratusan Qubit atau yang menargetkan hardware dengan coupling map yang rumit, transpiler AI menawarkan optimasi yang lebih baik dalam hal kedalaman Circuit, jumlah Gate, dan efisiensi waktu proses. Dalam pengujian benchmarking, metode ini secara konsisten mengungguli metode tradisional, menghasilkan Circuit yang jauh lebih dangkal dan mengurangi jumlah Gate — hal yang sangat penting untuk meningkatkan performa dan meredam noise pada hardware kuantum nyata.

Pengguna sebaiknya mempertimbangkan transpilasi berbasis AI saat bekerja dengan:

• Circuit besar di mana metode tradisional tidak mampu menangani skala secara efisien.
• Topologi hardware yang kompleks di mana konektivitas perangkat dan tantangan routing muncul.
• Aplikasi yang sensitif terhadap performa di mana mengurangi kedalaman Circuit dan meningkatkan fidelitas adalah hal utama.

Bagian III. Menjelajahi sintesis jaringan permutasi berbasis AI

Jaringan permutasi merupakan fondasi dalam komputasi kuantum, terutama untuk sistem yang dibatasi oleh topologi terbatas. Jaringan ini memfasilitasi interaksi jarak jauh dengan menukar Qubit secara dinamis untuk mensimulasikan konektivitas all-to-all pada hardware dengan konektivitas terbatas. Transformasi semacam ini sangat penting untuk mengimplementasikan algoritma kuantum kompleks pada perangkat near-term, di mana interaksi sering kali melampaui tetangga terdekat.

Di bagian ini, kita akan menyoroti sintesis jaringan permutasi sebagai kasus penggunaan yang menarik untuk transpiler berbasis AI di Qiskit. Secara khusus, pass AIPermutationSynthesis memanfaatkan optimasi berbasis AI untuk menghasilkan Circuit yang efisien untuk tugas permutasi Qubit. Sebaliknya, pendekatan sintesis generik sering kali kesulitan menyeimbangkan jumlah Gate dan kedalaman Circuit, terutama dalam skenario dengan interaksi Qubit yang padat atau saat mencoba mencapai konektivitas penuh.

Kita akan membahas contoh Qiskit patterns yang menampilkan sintesis jaringan permutasi untuk mencapai konektivitas all-to-all pada sekumpulan Qubit. Kita akan membandingkan performa AIPermutationSynthesis dengan metode sintesis standar di Qiskit. Contoh ini akan menunjukkan bagaimana transpiler AI mengoptimalkan kedalaman Circuit dan jumlah Gate yang lebih rendah, menonjolkan keunggulannya dalam alur kerja kuantum praktis. Untuk mengaktifkan pass sintesis AI, kita akan menggunakan fungsi generate_ai_pass_manager() dengan parameter include_ai_synthesis yang disetel ke True.

Langkah 1: Petakan input klasik ke masalah kuantum

Untuk merepresentasikan masalah permutasi klasik pada komputer kuantum, kita mulai dengan mendefinisikan struktur Circuit kuantum. Untuk contoh ini:

1. Inisialisasi Circuit kuantum: Kita mengalokasikan 27 Qubit agar sesuai dengan Backend yang akan digunakan, yang memiliki 27 Qubit.

2. Terapkan permutasi: Kita menghasilkan sepuluh pola permutasi acak (pattern_1 hingga pattern_10) menggunakan seed tetap untuk reproduktibilitas. Setiap pola permutasi diterapkan pada Circuit kuantum terpisah (qc_1 hingga qc_10).

3. Dekomposisi Circuit: Setiap operasi permutasi didekomposisi menjadi set gate native yang kompatibel dengan hardware kuantum target. Kita menganalisis kedalaman dan jumlah Gate dua-Qubit (gate nonlokal) untuk setiap Circuit yang didekomposisi.

Hasilnya memberikan wawasan tentang kompleksitas merepresentasikan masalah permutasi klasik pada perangkat kuantum, menunjukkan kebutuhan sumber daya untuk pola permutasi yang berbeda.

# 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: Optimalkan masalah untuk eksekusi hardware kuantum

Pada langkah ini, kita melanjutkan optimasi menggunakan AI synthesis passes.

Untuk AI synthesis passes, PassManager hanya memerlukan coupling map dari Backend. Namun, perlu dicatat bahwa tidak semua coupling map kompatibel; hanya yang telah dilatih oleh pass AIPermutationSynthesis yang akan berfungsi. Saat ini, pass AIPermutationSynthesis mendukung blok berukuran 65, 33, dan 27 Qubit. Untuk contoh ini kita menggunakan QPU 27-Qubit.

Sebagai perbandingan, kita akan mengevaluasi performa sintesis AI terhadap metode sintesis permutasi generik di Qiskit, termasuk:

• synth_permutation_depth_lnn_kms: Metode ini mensintesis Circuit permutasi untuk arsitektur linear nearest-neighbor (LNN) menggunakan algoritma Kutin, Moulton, dan Smithline (KMS). Metode ini menjamin Circuit dengan kedalaman paling banyak $n$ dan ukuran paling banyak $n(n-1)/2$, di mana kedalaman dan ukuran diukur dalam SWAP gates.

• synth_permutation_basic: Ini adalah implementasi sederhana yang mensintesis Circuit permutasi tanpa memberlakukan batasan konektivitas atau optimasi untuk arsitektur tertentu. Ini berfungsi sebagai baseline untuk membandingkan performa dengan metode yang lebih canggih.

Masing-masing metode ini mewakili pendekatan berbeda untuk mensintesis jaringan permutasi, memberikan benchmark komprehensif terhadap metode berbasis AI.

Untuk detail lebih lanjut tentang metode sintesis di Qiskit, lihat dokumentasi API Qiskit. Definisikan coupling map yang merepresentasikan 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()

Transpilasi setiap Circuit permutasi menggunakan AI synthesis passes dan metode 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)

Catat metrik (kedalaman, jumlah Gate, waktu) untuk setiap Circuit setelah 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

Hasil menunjukkan bahwa transpiler AI mengungguli semua metode sintesis Qiskit lainnya untuk set Circuit permutasi acak ini. Temuan utama meliputi:

1. Kedalaman: Transpiler AI mencapai kedalaman rata-rata terendah, menunjukkan optimasi layout Circuit yang superior.
2. Jumlah Gate: Metode ini secara signifikan mengurangi jumlah Gate dibandingkan metode lain, meningkatkan fidelitas dan efisiensi eksekusi.
3. Waktu transpilasi: Semua metode berjalan sangat cepat pada skala ini, sehingga praktis digunakan. Namun, transpiler AI memiliki peningkatan waktu proses yang signifikan dibandingkan metode tradisional karena kompleksitas model AI yang digunakan.

Hasil ini menjadikan transpiler AI sebagai pendekatan paling efektif untuk benchmark ini, terutama untuk optimasi kedalaman dan jumlah Gate. Plot hasil untuk membandingkan performa AI synthesis passes terhadap metode 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()

Grafik ini menyoroti hasil individual untuk setiap Circuit (qc_1 hingga qc_10) di berbagai metode sintesis:

Meskipun hasil ini menegaskan efektivitas transpiler AI untuk Circuit permutasi, penting untuk memperhatikan keterbatasannya. Metode sintesis AI saat ini hanya tersedia untuk coupling map tertentu, yang dapat membatasi penerapannya secara lebih luas. Batasan ini perlu dipertimbangkan saat mengevaluasi penggunaannya dalam skenario yang berbeda.

Secara keseluruhan, transpiler AI menunjukkan peningkatan yang menjanjikan dalam optimasi kedalaman dan jumlah Gate untuk Circuit-Circuit tertentu ini sambil mempertahankan waktu transpilasi yang sebanding.

Langkah 3: Eksekusi menggunakan Qiskit primitives

Karena tutorial ini berfokus pada transpilasi, tidak ada eksperimen yang akan dieksekusi pada perangkat kuantum. Tujuannya adalah memanfaatkan optimasi dari Langkah 2 untuk mendapatkan Circuit yang sudah ditranspilasi dengan kedalaman atau jumlah Gate yang lebih rendah.

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

Karena tidak ada eksekusi untuk notebook ini, tidak ada hasil yang perlu diproses lebih lanjut.

Survei tutorial

Silakan ikuti survei singkat ini untuk memberikan masukan tentang tutorial ini. Pandanganmu akan membantu kami meningkatkan konten dan pengalaman pengguna.

Tautan ke survei

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.