วิธีการคอมไพล์สำหรับ Hamiltonian simulation circuits

ประมาณการใช้งาน QPU: ไม่มีการรันในบทช่วยสอนนี้ เนื่องจากเนื้อหาเน้นที่กระบวนการ transpilation

พื้นหลัง

การคอมไพล์ quantum circuit เป็นขั้นตอนสำคัญในกระบวนการทำงาน quantum computing โดยเกี่ยวข้องกับการแปลง quantum algorithm ระดับสูงให้เป็น physical quantum circuit ที่ปฏิบัติตามข้อจำกัดของฮาร์ดแวร์ quantum เป้าหมาย การคอมไพล์ที่มีประสิทธิภาพส่งผลกระทบอย่างมีนัยสำคัญต่อประสิทธิภาพของ quantum algorithms โดยลด circuit depth, gate count, และเวลาในการรัน บทช่วยสอนนี้สำรวจสามแนวทางที่แตกต่างกันสำหรับการคอมไพล์ quantum circuit ใน Qiskit พร้อมแสดงจุดแข็งและการประยุกต์ใช้ผ่านตัวอย่างเชิงปฏิบัติ

เป้าหมายของบทช่วยสอนนี้คือสอนผู้ใช้ให้รู้จักการนำและประเมินวิธีการคอมไพล์สามแบบใน Qiskit ได้แก่ SABRE transpiler, AI-powered transpiler, และ Rustiq plugin ผู้ใช้จะได้เรียนรู้วิธีใช้แต่ละวิธีอย่างมีประสิทธิภาพและวิธีวัดประสิทธิภาพใน quantum circuits ต่าง ๆ เมื่อจบบทช่วยสอนนี้ ผู้ใช้จะสามารถเลือกและปรับกลยุทธ์การคอมไพล์ตามเป้าหมายการปรับแต่งที่ต้องการ เช่น การลด circuit depth, การลด gate count, หรือการเพิ่มความเร็วในการรัน

สิ่งที่จะได้เรียนรู้

• วิธีใช้ Qiskit transpiler กับ SABRE สำหรับการปรับแต่ง layout และ routing
• วิธีใช้ประโยชน์จาก AI transpiler สำหรับการปรับแต่ง circuit อัตโนมัติขั้นสูง
• วิธีใช้ Rustiq plugin สำหรับ circuits ที่ต้องการการสังเคราะห์การดำเนินการอย่างแม่นยำ โดยเฉพาะในงาน Hamiltonian simulation

บทช่วยสอนนี้ใช้ตัวอย่าง circuits สามแบบตาม workflow ของ Qiskit patterns เพื่อแสดงประสิทธิภาพของแต่ละวิธีการคอมไพล์ เมื่อจบบทช่วยสอนนี้ ผู้ใช้จะมีความพร้อมในการเลือกกลยุทธ์การคอมไพล์ที่เหมาะสมตามความต้องการและข้อจำกัดของตัวเอง

ภาพรวมวิธีการคอมไพล์

1. Qiskit transpiler กับ SABRE

Qiskit transpiler ใช้อัลกอริทึม SABRE (SWAP-based BidiREctional heuristic search) เพื่อปรับแต่ง circuit layout และ routing SABRE มุ่งเน้นการลด SWAP gates และผลกระทบต่อ circuit depth ขณะที่ปฏิบัติตามข้อจำกัดการเชื่อมต่อของฮาร์ดแวร์ วิธีนี้มีความยืดหยุ่นสูงและเหมาะสำหรับการปรับแต่ง circuit วัตถุประสงค์ทั่วไป ให้ความสมดุลระหว่างประสิทธิภาพและเวลาในการคำนวณ เพื่อใช้ประโยชน์จากการปรับปรุงล่าสุดใน SABRE ที่อธิบายใน [1] สามารถเพิ่มจำนวน trials ได้ (เช่น layout_trials=400, swap_trials=400) สำหรับบทช่วยสอนนี้ เราจะใช้ค่าเริ่มต้นสำหรับจำนวน trials เพื่อเปรียบเทียบกับ Qiskit's default transpiler ข้อดีและการสำรวจพารามิเตอร์ของ SABRE ถูกครอบคลุมใน บทช่วยสอนเชิงลึกแยก

2. AI transpiler

AI-powered transpiler ใน Qiskit ใช้ machine learning เพื่อทำนายกลยุทธ์ transpilation ที่ดีที่สุด โดยวิเคราะห์รูปแบบในโครงสร้าง circuit และข้อจำกัดของฮาร์ดแวร์เพื่อเลือกลำดับการปรับแต่งที่ดีที่สุดสำหรับ input ที่กำหนด วิธีนี้มีประสิทธิภาพเป็นพิเศษสำหรับ quantum circuits ขนาดใหญ่ ให้ระดับการทำงานอัตโนมัติและความสามารถปรับตัวกับปัญหาประเภทต่าง ๆ สูง นอกเหนือจากการปรับแต่ง circuit ทั่วไปแล้ว AI transpiler ยังสามารถใช้กับ pass AIPauliNetworkSynthesis ซึ่งมุ่งเป้าที่ Pauli network circuits — บล็อกที่ประกอบด้วย H, S, SX, CX, RX, RY, และ RZ gates — และใช้วิธีการสังเคราะห์แบบ reinforcement learning สำหรับข้อมูลเพิ่มเติมเกี่ยวกับ AI transpiler และกลยุทธ์การสังเคราะห์ ดู [2] และ [3]

3. Rustiq plugin

Rustiq plugin แนะนำเทคนิคการสังเคราะห์ขั้นสูงโดยเฉพาะสำหรับ PauliEvolutionGate operations ที่แสดง Pauli rotations ที่ใช้กันทั่วไปใน Trotterized dynamics plugin นี้มีคุณค่าสำหรับ circuits ที่ใช้ Hamiltonian simulation เช่น circuits ที่ใช้ใน quantum chemistry และฟิสิกส์ ซึ่ง Pauli rotations ที่แม่นยำมีความสำคัญสำหรับการจำลอง problem Hamiltonians อย่างมีประสิทธิภาพ Rustiq มอบการสังเคราะห์ circuit ที่แม่นยำและมี depth ต่ำสำหรับ operations เฉพาะทางเหล่านี้ สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับการใช้งานและประสิทธิภาพของ Rustiq ดู [4]

จากการสำรวจวิธีการคอมไพล์เหล่านี้อย่างละเอียด บทช่วยสอนนี้มอบเครื่องมือให้ผู้ใช้เพิ่มประสิทธิภาพ quantum circuits ของตน เปิดทางสู่การคำนวณ quantum ที่มีประสิทธิภาพและใช้งานได้จริงมากขึ้น

ข้อกำหนด

ก่อนเริ่มบทช่วยสอนนี้ ตรวจสอบให้แน่ใจว่าติดตั้งสิ่งต่อไปนี้แล้ว:

• Qiskit SDK v1.3 หรือใหม่กว่า พร้อมรองรับ visualization
• Qiskit Runtime v0.28 หรือใหม่กว่า (pip install qiskit-ibm-runtime)
• Qiskit IBM Transpiler (pip install qiskit-ibm-transpiler)
• Qiskit AI Transpiler local mode (pip install qiskit_ibm_ai_local_transpiler)
• Networkx graph library (pip install networkx)

ตั้งค่า

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

from qiskit.circuit import QuantumCircuit
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit.circuit.library import (
    efficient_su2,
    PauliEvolutionGate,
)
from qiskit_ibm_transpiler import generate_ai_pass_manager
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit.transpiler.passes.synthesis.high_level_synthesis import HLSConfig
from collections import Counter
from IPython.display import display
import time
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
import json
import requests
import logging

# Suppress noisy loggers
logging.getLogger(
    "qiskit_ibm_transpiler.wrappers.ai_local_synthesis"
).setLevel(logging.ERROR)

seed = 42  # Seed for reproducibility

ส่วนที่ 1: Efficient SU2 Circuit

ขั้นตอนที่ 1: แปลง input แบบ classical เป็น quantum problem

ในส่วนนี้ เราสำรวจ efficient_su2 circuit ซึ่งเป็น hardware-efficient ansatz ที่ใช้กันทั่วไปในอัลกอริทึม variational quantum (เช่น VQE) และงาน quantum machine learning circuit ประกอบด้วยชั้น single-qubit rotations และ entangling gates สลับกันในรูปแบบวงกลม ออกแบบมาเพื่อสำรวจ quantum state space อย่างมีประสิทธิภาพขณะรักษา depth ให้จัดการได้

เราจะเริ่มด้วยการสร้าง efficient_su2 circuit หนึ่งตัวเพื่อแสดงวิธีเปรียบเทียบวิธีการคอมไพล์ต่าง ๆ หลังจากส่วนที่ 1 เราจะขยายการวิเคราะห์ไปยัง circuits จำนวนมากขึ้น เพื่อให้ได้ benchmark ที่ครอบคลุมสำหรับประเมินประสิทธิภาพของเทคนิคการคอมไพล์ต่าง ๆ

qubit_size = list(range(10, 101, 10))
qc_su2_list = [
    efficient_su2(n, entanglement="circular", reps=1)
    .decompose()
    .copy(name=f"SU2_{n}")
    for n in qubit_size
]

# Draw the first circuit
qc_su2_list[0].draw(output="mpl")

ขั้นตอนที่ 2: ปรับแต่ง problem สำหรับการรันบนฮาร์ดแวร์ quantum

ขั้นตอนนี้เป็นจุดสนใจหลักของบทช่วยสอน ที่นี่เรามุ่งหมายปรับแต่ง quantum circuits เพื่อการรันอย่างมีประสิทธิภาพบนฮาร์ดแวร์ quantum จริง เป้าหมายหลักของเราคือลด circuit depth และ gate count ซึ่งเป็นปัจจัยสำคัญในการปรับปรุง execution fidelity และลด hardware noise

• SABRE transpiler: ใช้ Qiskit's default transpiler กับอัลกอริทึม SABRE layout และ routing
• AI transpiler (local mode): AI-powered transpiler มาตรฐานที่ใช้ local inference และกลยุทธ์การสังเคราะห์เริ่มต้น
• Rustiq plugin: transpiler plugin ที่ออกแบบมาสำหรับการคอมไพล์ depth ต่ำที่ปรับแต่งสำหรับงาน Hamiltonian simulation

เป้าหมายของขั้นตอนนี้คือเปรียบเทียบผลลัพธ์ของวิธีเหล่านี้ในแง่ depth และ gate count ของ transpiled circuit เมตริกสำคัญอีกตัวที่พิจารณาคือ transpilation runtime โดยการวิเคราะห์เมตริกเหล่านี้ เราสามารถประเมินจุดแข็งสัมพัทธ์ของแต่ละวิธีและพิจารณาว่าวิธีใดสร้าง circuit ที่มีประสิทธิภาพสูงสุดสำหรับการรันบนฮาร์ดแวร์ที่เลือก

หมายเหตุ: สำหรับตัวอย่าง SU2 circuit เริ่มต้น เราจะเปรียบเทียบเฉพาะ SABRE transpiler กับ AI transpiler เริ่มต้นเท่านั้น อย่างไรก็ตาม ใน benchmark ถัดไปที่ใช้ Hamlib circuits เราจะเปรียบเทียบวิธีการ transpilation ทั้งสามแบบ

# QiskitRuntimeService.save_account(channel="ibm_quantum_platform", token="<YOUR-API-KEY>", overwrite=True, set_as_default=True)
service = QiskitRuntimeService(channel="ibm_quantum_platform")
backend = service.backend("ibm_torino")
print(f"Using backend: {backend}")

qiskit_runtime_service._get_crn_from_instance_name:WARNING:2025-07-30 21:46:30,843: Multiple instances found. Using all matching instances.

Using backend: <IBMBackend('ibm_torino')>

Qiskit transpiler กับ SABRE:

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

AI transpiler:

# Standard AI transpiler pass manager, using the local mode
pm_ai = generate_ai_pass_manager(
    backend=backend, optimization_level=3, ai_optimization_level=3
)

Rustiq plugin:

hls_config = HLSConfig(
    PauliEvolution=[
        (
            "rustiq",
            {
                "nshuffles": 400,
                "upto_phase": True,
                "fix_clifford": True,
                "preserve_order": False,
                "metric": "depth",
            },
        )
    ]
)
pm_rustiq = generate_preset_pass_manager(
    optimization_level=3,
    backend=backend,
    hls_config=hls_config,
    seed_transpiler=seed,
)

Transpile และเก็บเมตริก

เพื่อเปรียบเทียบประสิทธิภาพของวิธีการคอมไพล์ เราจะกำหนดฟังก์ชันที่ transpile input circuit และเก็บเมตริกที่เกี่ยวข้องในลักษณะสม่ำเสมอ ซึ่งรวมถึง circuit depth รวม, gate count รวม, และเวลา transpilation

นอกจากเมตริกมาตรฐานเหล่านี้แล้ว เรายังบันทึก 2-qubit gate depth ซึ่งเป็นเมตริกที่สำคัญมากสำหรับการประเมินการรันบนฮาร์ดแวร์ quantum ต่างจาก total depth ที่รวม gates ทั้งหมด 2-qubit depth สะท้อนถึง*ระยะเวลาการรันจริงบนฮาร์ดแวร์ได้แม่นยำกว่า เนื่องจาก 2-qubit gates มักครอบงำงบประมาณเวลาและข้อผิดพลาดในอุปกรณ์ quantum ส่วนใหญ่ ดังนั้น การลด 2-qubit depth จึงมีความสำคัญสำหรับการปรับปรุง fidelity และลดผลกระทบจาก decoherence ระหว่างการรัน

เราจะใช้ฟังก์ชันนี้เพื่อวิเคราะห์ประสิทธิภาพของวิธีการคอมไพล์ต่าง ๆ ข้าม circuits หลายตัว

def capture_transpilation_metrics(
    results, pass_manager, circuits, method_name
):
    """
    Capture transpilation metrics for a list of circuits and stores the results in a DataFrame.

    Args:
        results (pd.DataFrame): DataFrame to store the results.
        pass_manager: Pass manager used for transpilation.
        circuits (list): List of quantum circuits to transpile.
        method_name (str): Name of the transpilation method.

    Returns:
        list: List of transpiled circuits.
    """
    transpiled_circuits = []

    for i, qc in enumerate(circuits):
        # Transpile the circuit
        start_time = time.time()
        transpiled_qc = pass_manager.run(qc)
        end_time = time.time()

        # Needed for AI transpiler to be consistent with other methods
        transpiled_qc = transpiled_qc.decompose(gates_to_decompose=["swap"])

        # Collect metrics
        transpilation_time = end_time - start_time
        circuit_depth = transpiled_qc.depth(
            lambda x: x.operation.num_qubits == 2
        )
        circuit_size = transpiled_qc.size()

        # Append results to DataFrame
        results.loc[len(results)] = {
            "method": method_name,
            "qc_name": qc.name,
            "qc_index": i,
            "num_qubits": qc.num_qubits,
            "ops": transpiled_qc.count_ops(),
            "depth": circuit_depth,
            "size": circuit_size,
            "runtime": transpilation_time,
        }
        transpiled_circuits.append(transpiled_qc)
        print(
            f"Transpiled circuit index {i} ({qc.name}) in {transpilation_time:.2f} seconds with method {method_name}, "
            f"depth {circuit_depth}, and size {circuit_size}."
        )

    return transpiled_circuits

results_su2 = pd.DataFrame(
    columns=[
        "method",
        "qc_name",
        "qc_index",
        "num_qubits",
        "ops",
        "depth",
        "size",
        "runtime",
    ]
)

tqc_sabre = capture_transpilation_metrics(
    results_su2, pm_sabre, qc_su2_list, "sabre"
)
tqc_ai = capture_transpilation_metrics(results_su2, pm_ai, qc_su2_list, "ai")

Transpiled circuit index 0 (SU2_10) in 0.06 seconds with method sabre, depth 13, and size 167.
Transpiled circuit index 1 (SU2_20) in 0.24 seconds with method sabre, depth 20, and size 299.
Transpiled circuit index 2 (SU2_30) in 10.72 seconds with method sabre, depth 72, and size 627.
Transpiled circuit index 3 (SU2_40) in 16.16 seconds with method sabre, depth 40, and size 599.
Transpiled circuit index 4 (SU2_50) in 76.89 seconds with method sabre, depth 77, and size 855.
Transpiled circuit index 5 (SU2_60) in 86.12 seconds with method sabre, depth 60, and size 899.
Transpiled circuit index 6 (SU2_70) in 94.46 seconds with method sabre, depth 79, and size 1085.
Transpiled circuit index 7 (SU2_80) in 69.05 seconds with method sabre, depth 80, and size 1199.
Transpiled circuit index 8 (SU2_90) in 88.25 seconds with method sabre, depth 105, and size 1420.
Transpiled circuit index 9 (SU2_100) in 83.80 seconds with method sabre, depth 100, and size 1499.
Transpiled circuit index 0 (SU2_10) in 0.17 seconds with method ai, depth 10, and size 168.
Transpiled circuit index 1 (SU2_20) in 0.29 seconds with method ai, depth 20, and size 299.
Transpiled circuit index 2 (SU2_30) in 13.56 seconds with method ai, depth 36, and size 548.
Transpiled circuit index 3 (SU2_40) in 15.95 seconds with method ai, depth 40, and size 599.
Transpiled circuit index 4 (SU2_50) in 80.70 seconds with method ai, depth 54, and size 823.
Transpiled circuit index 5 (SU2_60) in 75.99 seconds with method ai, depth 60, and size 899.
Transpiled circuit index 6 (SU2_70) in 64.96 seconds with method ai, depth 74, and size 1087.
Transpiled circuit index 7 (SU2_80) in 68.25 seconds with method ai, depth 80, and size 1199.
Transpiled circuit index 8 (SU2_90) in 75.07 seconds with method ai, depth 90, and size 1404.
Transpiled circuit index 9 (SU2_100) in 63.97 seconds with method ai, depth 100, and size 1499.

แสดงผลลัพธ์ transpiled ของ circuit หนึ่งตัว

print("Sabre transpilation")
display(tqc_sabre[0].draw("mpl", fold=-1, idle_wires=False))
print("AI transpilation")
display(tqc_ai[0].draw("mpl", fold=-1, idle_wires=False))

Sabre transpilation

AI transpilation

ตารางผลลัพธ์:

summary_su2 = (
    results_su2.groupby("method")[["depth", "size", "runtime"]]
    .mean()
    .round(2)
)
print(summary_su2)

results_su2

depth   size  runtime
method
ai       56.4  852.5    45.89
sabre    64.6  864.9    52.57

method  qc_name  qc_index  num_qubits                                ops  \
0   sabre   SU2_10         0          10     {'rz': 81, 'sx': 70, 'cz': 16}
1   sabre   SU2_20         1          20   {'rz': 160, 'sx': 119, 'cz': 20}
2   sabre   SU2_30         2          30   {'sx': 295, 'rz': 242, 'cz': 90}
3   sabre   SU2_40         3          40   {'rz': 320, 'sx': 239, 'cz': 40}
4   sabre   SU2_50         4          50   {'rz': 402, 'sx': 367, 'cz': 86}
5   sabre   SU2_60         5          60   {'rz': 480, 'sx': 359, 'cz': 60}
6   sabre   SU2_70         6          70   {'rz': 562, 'sx': 441, 'cz': 82}
7   sabre   SU2_80         7          80   {'rz': 640, 'sx': 479, 'cz': 80}
8   sabre   SU2_90         8          90  {'rz': 721, 'sx': 585, 'cz': 114}
9   sabre  SU2_100         9         100  {'rz': 800, 'sx': 599, 'cz': 100}
10     ai   SU2_10         0          10     {'rz': 81, 'sx': 71, 'cz': 16}
11     ai   SU2_20         1          20   {'rz': 160, 'sx': 119, 'cz': 20}
12     ai   SU2_30         2          30   {'sx': 243, 'rz': 242, 'cz': 63}
13     ai   SU2_40         3          40   {'rz': 320, 'sx': 239, 'cz': 40}
14     ai   SU2_50         4          50   {'rz': 403, 'sx': 346, 'cz': 74}
15     ai   SU2_60         5          60   {'rz': 480, 'sx': 359, 'cz': 60}
16     ai   SU2_70         6          70   {'rz': 563, 'sx': 442, 'cz': 82}
17     ai   SU2_80         7          80   {'rz': 640, 'sx': 479, 'cz': 80}
18     ai   SU2_90         8          90  {'rz': 721, 'sx': 575, 'cz': 108}
19     ai  SU2_100         9         100  {'rz': 800, 'sx': 599, 'cz': 100}

    depth  size    runtime
0      13   167   0.058845
1      20   299   0.238217
2      72   627  10.723922
3      40   599  16.159262
4      77   855  76.886604
5      60   899  86.118255
6      79  1085  94.458287
7      80  1199  69.048184
8     105  1420  88.254809
9     100  1499  83.795482
10     10   168   0.171532
11     20   299   0.291691
12     36   548  13.555931
13     40   599  15.952733
14     54   823  80.702141
15     60   899  75.993404
16     74  1087  64.960162
17     80  1199  68.253280
18     90  1404  75.072412
19    100  1499  63.967446

กราฟผลลัพธ์

เช่นเดียวกับที่เรากำหนดฟังก์ชันสำหรับเก็บเมตริกอย่างสม่ำเสมอ เราจะกำหนดฟังก์ชันสำหรับแสดงกราฟเมตริกด้วย ที่นี่เราจะ plot 2-qubit depth, gate count, และ runtime สำหรับแต่ละวิธีการคอมไพล์ข้าม circuits ต่าง ๆ

def plot_transpilation_metrics(results, overall_title, x_axis="qc_index"):
    """
    Plots transpilation metrics (depth, size, runtime) for different transpilation methods.

    Parameters:
        results (DataFrame): Data containing columns ['num_qubits', 'method', 'depth', 'size', 'runtime']
        overall_title (str): The title of the overall figure.
        x_axis (str): The x-axis label, either 'num_qubits' or 'qc_index'.
    """

    fig, axs = plt.subplots(1, 3, figsize=(24, 6))
    metrics = ["depth", "size", "runtime"]
    titles = ["Circuit Depth", "Circuit Size", "Transpilation Runtime"]
    y_labels = ["Depth", "Size (Gate Count)", "Runtime (s)"]

    methods = results["method"].unique()
    colors = plt.colormaps["tab10"]
    markers = ["o", "^", "s", "D", "P", "*", "X", "v"]
    color_list = [colors(i % colors.N) for i in range(len(methods))]
    color_map = {method: color_list[i] for i, method in enumerate(methods)}
    marker_map = {
        method: markers[i % len(markers)] for i, method in enumerate(methods)
    }
    jitter_factor = 0.1  # Small x-axis jitter for visibility
    handles, labels = [], []  # Unique handles for legend

    # Plot each metric
    for i, metric in enumerate(metrics):
        for method in methods:
            method_data = results[results["method"] == method]

            # Introduce slight jitter to avoid exact overlap
            jitter = np.random.uniform(
                -jitter_factor, jitter_factor, len(method_data)
            )

            scatter = axs[i].scatter(
                method_data[x_axis] + jitter,
                method_data[metric],
                color=color_map[method],
                label=method,
                marker=marker_map[method],
                alpha=0.7,
                edgecolors="black",
                s=80,
            )

            if method not in labels:
                handles.append(scatter)
                labels.append(method)

        axs[i].set_title(titles[i])
        axs[i].set_xlabel(x_axis)
        axs[i].set_ylabel(y_labels[i])
        axs[i].grid(axis="y", linestyle="--", alpha=0.7)
        axs[i].tick_params(axis="x", rotation=45)
        axs[i].set_xticks(sorted(results[x_axis].unique()))

    fig.suptitle(overall_title, fontsize=16)
    fig.legend(
        handles=handles,
        labels=labels,
        loc="upper right",
        bbox_to_anchor=(1.05, 1),
    )

    plt.tight_layout()
    plt.show()

plot_transpilation_metrics(
    results_su2, "Transpilation Metrics for SU2 Circuits", x_axis="num_qubits"
)

การวิเคราะห์ผลลัพธ์การคอมไพล์ SU2 circuit

ในการทดลองนี้ เราเปรียบเทียบสองวิธี transpilation ได้แก่ Qiskit's SABRE transpiler และ AI-powered transpiler บน efficient_su2 circuits หลายชุด เนื่องจาก circuits เหล่านี้ไม่รวม PauliEvolutionGate operations ใด ๆ Rustiq plugin จึงไม่ถูกรวมในการเปรียบเทียบนี้

โดยเฉลี่ย AI transpiler ทำงานได้ดีกว่าในแง่ circuit depth โดยมีการปรับปรุงมากกว่า 10% ทั่ว SU2 circuits ทั้งหมด สำหรับ gate count (circuit size) และ transpilation runtime ทั้งสองวิธีให้ผลลัพธ์ที่ใกล้เคียงกันโดยรวม

อย่างไรก็ตาม การตรวจสอบจุดข้อมูลแต่ละตัวเผยให้เห็นข้อมูลเชิงลึกที่ลึกซึ้งกว่า:

• สำหรับขนาด qubit ส่วนใหญ่ ทั้ง SABRE และ AI ให้ผลลัพธ์ที่เกือบเหมือนกัน แสดงว่าในหลายกรณี ทั้งสองวิธีมาบรรจบกันที่ solution ที่มีประสิทธิภาพใกล้เคียงกัน
• สำหรับขนาด circuit บางขนาด โดยเฉพาะที่ 30, 50, 70, และ 90 qubits AI transpiler พบ circuits ที่ shallow กว่า SABRE อย่างมีนัยสำคัญ ซึ่งชี้ให้เห็นว่าแนวทาง learning-based ของ AI สามารถค้นพบ layouts หรือ routing paths ที่ optimal กว่าในกรณีที่ SABRE heuristic ไม่สามารถทำได้

พฤติกรรมนี้เน้นย้ำข้อสรุปที่สำคัญ:

แม้ SABRE และ AI มักให้ผลลัพธ์ที่เปรียบได้ AI transpiler บางครั้งสามารถค้นพบ solutions ที่ดีกว่ามาก โดยเฉพาะในแง่ depth ซึ่งสามารถนำไปสู่ประสิทธิภาพที่ดีขึ้นอย่างมีนัยสำคัญบนฮาร์ดแวร์

ส่วนที่ 2: Circuit การจำลอง Hamiltonian

ขั้นตอนที่ 1: ตรวจสอบ Circuit ด้วย PauliEvolutionGate

ในส่วนนี้ เราจะตรวจสอบ Circuit ควอนตัมที่สร้างขึ้นโดยใช้ PauliEvolutionGate ซึ่งช่วยให้จำลอง Hamiltonian ได้อย่างมีประสิทธิภาพ เราจะวิเคราะห์ว่าวิธีคอมไพล์ต่าง ๆ ปรับ Circuit เหล่านี้ให้เหมาะสมข้ามกลุ่ม Hamiltonian หลากหลายได้อย่างไร

Hamiltonian ที่ใช้ใน Benchmark

Hamiltonian ที่ใช้ใน Benchmark นี้อธิบายปฏิสัมพันธ์แบบคู่ระหว่าง Qubit ซึ่งรวมถึงพจน์ต่าง ๆ เช่น $ZZ$, $XX$ และ $YY$ Hamiltonian เหล่านี้ใช้กันทั่วไปในเคมีควอนตัม ฟิสิกส์สสารควบแน่น และวิทยาศาสตร์วัสดุ ซึ่งเป็นตัวแบบระบบของอนุภาคที่มีปฏิสัมพันธ์กัน

สำหรับข้อมูลอ้างอิง ผู้ใช้สามารถสำรวจกลุ่ม Hamiltonian ที่กว้างกว่านี้ได้จากบทความนี้: Efficient Hamiltonian Simulation on Noisy Quantum Devices

แหล่งที่มาของ Benchmark: Hamlib และ Benchpress

Circuit ที่ใช้ใน Benchmark นี้มาจาก Hamlib benchmark repository ซึ่งมีภาระงานการจำลอง Hamiltonian ที่สมจริง

Circuit เหล่านี้ถูก Benchmark มาก่อนแล้วโดยใช้ Benchpress ซึ่งเป็น Framework โอเพนซอร์สสำหรับประเมินประสิทธิภาพการ Transpile ควอนตัม การใช้ชุด Circuit มาตรฐานนี้ทำให้เราเปรียบเทียบประสิทธิผลของกลยุทธ์การคอมไพล์ต่าง ๆ บนปัญหาจำลองที่เป็นตัวแทนได้โดยตรง

การจำลอง Hamiltonian เป็นงานพื้นฐานในการคำนวณควอนตัม มีการประยุกต์ใช้ในการจำลองโมเลกุล ปัญหาการปรับให้เหมาะสม และฟิสิกส์หลายวัตถุควอนตัม การเข้าใจว่าวิธีคอมไพล์ต่าง ๆ ปรับ Circuit เหล่านี้ให้เหมาะสมอย่างไร จะช่วยให้ผู้ใช้ปรับปรุงการรันจริงบนอุปกรณ์ควอนตัมช่วงใกล้ได้

# Obtain the Hamiltonian JSON from the benchpress repository
url = "https://raw.githubusercontent.com/Qiskit/benchpress/e7b29ef7be4cc0d70237b8fdc03edbd698908eff/benchpress/hamiltonian/hamlib/100_representative.json"
response = requests.get(url)
response.raise_for_status()  # Raise an error if download failed
ham_records = json.loads(response.text)
# Remove circuits that are too large for the backend
ham_records = [
    h for h in ham_records if h["ham_qubits"] <= backend.num_qubits
]
# Remove the circuits that are large to save transpilation time
ham_records = sorted(ham_records, key=lambda x: x["ham_terms"])[:35]

qc_ham_list = []
for h in ham_records:
    terms = h["ham_hamlib_hamiltonian_terms"]
    coeff = h["ham_hamlib_hamiltonian_coefficients"]
    num_qubits = h["ham_qubits"]
    name = h["ham_problem"]

    evo_gate = PauliEvolutionGate(SparsePauliOp(terms, coeff))

    qc_ham = QuantumCircuit(num_qubits)
    qc_ham.name = name

    qc_ham.append(evo_gate, range(num_qubits))
    qc_ham_list.append(qc_ham)
print(f"Number of Hamiltonian circuits: {len(qc_ham_list)}")

# Draw the first Hamiltonian circuit
qc_ham_list[0].draw("mpl", fold=-1)

Number of Hamiltonian circuits: 35

ขั้นตอนที่ 2: ปรับโจทย์ให้เหมาะสมสำหรับการรันบน Hardware ควอนตัม

เช่นเดียวกับตัวอย่างก่อนหน้า เราจะใช้ Backend เดิมเพื่อให้การเปรียบเทียบสอดคล้องกัน เนื่องจาก Pass Manager (pm_sabre, pm_ai และ pm_rustiq) ได้เริ่มต้นไว้แล้ว เราจึงสามารถดำเนินการ Transpile Circuit Hamiltonian ด้วยแต่ละวิธีได้ทันที

ขั้นตอนนี้มุ่งเน้นที่การ Transpile และบันทึกตัวชี้วัดของ Circuit ที่ได้ ทั้ง depth จำนวน Gate และเวลาที่ใช้ในการ Transpile การวิเคราะห์ผลเหล่านี้จะช่วยให้เราระบุประสิทธิภาพของแต่ละวิธี Transpile สำหรับ Circuit ประเภทนี้ได้ Transpile และบันทึกตัวชี้วัด:

results_ham = pd.DataFrame(
    columns=[
        "method",
        "qc_name",
        "qc_index",
        "num_qubits",
        "ops",
        "depth",
        "size",
        "runtime",
    ]
)

tqc_sabre = capture_transpilation_metrics(
    results_ham, pm_sabre, qc_ham_list, "sabre"
)
tqc_ai = capture_transpilation_metrics(results_ham, pm_ai, qc_ham_list, "ai")
tqc_rustiq = capture_transpilation_metrics(
    results_ham, pm_rustiq, qc_ham_list, "rustiq"
)

Transpiled circuit index 0 (all-vib-o3) in 0.02 seconds with method sabre, depth 6, and size 58.
Transpiled circuit index 1 (all-vib-c2h) in 1.10 seconds with method sabre, depth 2, and size 39.
Transpiled circuit index 2 (all-vib-bh) in 0.01 seconds with method sabre, depth 3, and size 30.
Transpiled circuit index 3 (all-vib-c2h) in 0.03 seconds with method sabre, depth 18, and size 115.
Transpiled circuit index 4 (graph-gnp_k-2) in 0.02 seconds with method sabre, depth 24, and size 129.
Transpiled circuit index 5 (all-vib-fccf) in 0.05 seconds with method sabre, depth 14, and size 134.
Transpiled circuit index 6 (all-vib-hno) in 8.39 seconds with method sabre, depth 6, and size 174.
Transpiled circuit index 7 (all-vib-bhf2) in 3.92 seconds with method sabre, depth 22, and size 220.
Transpiled circuit index 8 (LiH) in 0.03 seconds with method sabre, depth 67, and size 290.
Transpiled circuit index 9 (uf20-ham) in 0.04 seconds with method sabre, depth 50, and size 340.
Transpiled circuit index 10 (all-vib-fccf) in 0.62 seconds with method sabre, depth 30, and size 286.
Transpiled circuit index 11 (all-vib-fccf) in 0.04 seconds with method sabre, depth 67, and size 339.
Transpiled circuit index 12 (all-vib-ch2) in 0.04 seconds with method sabre, depth 87, and size 421.
Transpiled circuit index 13 (tfim) in 0.05 seconds with method sabre, depth 36, and size 222.
Transpiled circuit index 14 (all-vib-cyclo_propene) in 9.51 seconds with method sabre, depth 22, and size 345.
Transpiled circuit index 15 (graph-gnp_k-4) in 0.05 seconds with method sabre, depth 128, and size 704.
Transpiled circuit index 16 (all-vib-hc3h2cn) in 13.83 seconds with method sabre, depth 2, and size 242.
Transpiled circuit index 17 (TSP_Ncity-4) in 0.05 seconds with method sabre, depth 106, and size 609.
Transpiled circuit index 18 (tfim) in 0.29 seconds with method sabre, depth 73, and size 399.
Transpiled circuit index 19 (all-vib-h2co) in 21.97 seconds with method sabre, depth 30, and size 572.
Transpiled circuit index 20 (Be2) in 0.09 seconds with method sabre, depth 324, and size 1555.
Transpiled circuit index 21 (graph-complete_bipart) in 0.12 seconds with method sabre, depth 250, and size 1394.
Transpiled circuit index 22 (all-vib-f2) in 0.07 seconds with method sabre, depth 215, and size 1027.
Transpiled circuit index 23 (all-vib-cyclo_propene) in 41.22 seconds with method sabre, depth 30, and size 1144.
Transpiled circuit index 24 (TSP_Ncity-5) in 1.89 seconds with method sabre, depth 175, and size 1933.
Transpiled circuit index 25 (H2) in 0.32 seconds with method sabre, depth 1237, and size 5502.
Transpiled circuit index 26 (uuf100-ham) in 0.20 seconds with method sabre, depth 385, and size 4303.
Transpiled circuit index 27 (ham-graph-gnp_k-5) in 0.20 seconds with method sabre, depth 311, and size 3654.
Transpiled circuit index 28 (tfim) in 0.15 seconds with method sabre, depth 276, and size 3213.
Transpiled circuit index 29 (uuf100-ham) in 0.21 seconds with method sabre, depth 520, and size 5250.
Transpiled circuit index 30 (flat100-ham) in 0.15 seconds with method sabre, depth 131, and size 3157.
Transpiled circuit index 31 (uf100-ham) in 0.24 seconds with method sabre, depth 624, and size 7378.
Transpiled circuit index 32 (OH) in 0.88 seconds with method sabre, depth 2175, and size 9808.
Transpiled circuit index 33 (HF) in 0.66 seconds with method sabre, depth 2206, and size 9417.
Transpiled circuit index 34 (BH) in 0.89 seconds with method sabre, depth 2177, and size 9802.
Transpiled circuit index 0 (all-vib-o3) in 0.02 seconds with method ai, depth 6, and size 58.
Transpiled circuit index 1 (all-vib-c2h) in 1.11 seconds with method ai, depth 2, and size 39.
Transpiled circuit index 2 (all-vib-bh) in 0.01 seconds with method ai, depth 3, and size 30.
Transpiled circuit index 3 (all-vib-c2h) in 0.11 seconds with method ai, depth 18, and size 94.
Transpiled circuit index 4 (graph-gnp_k-2) in 0.11 seconds with method ai, depth 22, and size 129.
Transpiled circuit index 5 (all-vib-fccf) in 0.06 seconds with method ai, depth 22, and size 177.
Transpiled circuit index 6 (all-vib-hno) in 8.62 seconds with method ai, depth 10, and size 198.
Transpiled circuit index 7 (all-vib-bhf2) in 3.71 seconds with method ai, depth 18, and size 195.
Transpiled circuit index 8 (LiH) in 0.19 seconds with method ai, depth 62, and size 267.
Transpiled circuit index 9 (uf20-ham) in 0.22 seconds with method ai, depth 47, and size 321.
Transpiled circuit index 10 (all-vib-fccf) in 0.71 seconds with method ai, depth 38, and size 369.
Transpiled circuit index 11 (all-vib-fccf) in 0.24 seconds with method ai, depth 65, and size 315.
Transpiled circuit index 12 (all-vib-ch2) in 0.24 seconds with method ai, depth 91, and size 430.
Transpiled circuit index 13 (tfim) in 0.15 seconds with method ai, depth 12, and size 251.
Transpiled circuit index 14 (all-vib-cyclo_propene) in 8.50 seconds with method ai, depth 18, and size 311.
Transpiled circuit index 15 (graph-gnp_k-4) in 0.25 seconds with method ai, depth 117, and size 659.
Transpiled circuit index 16 (all-vib-hc3h2cn) in 16.11 seconds with method ai, depth 2, and size 242.
Transpiled circuit index 17 (TSP_Ncity-4) in 0.39 seconds with method ai, depth 98, and size 564.
Transpiled circuit index 18 (tfim) in 0.38 seconds with method ai, depth 23, and size 437.
Transpiled circuit index 19 (all-vib-h2co) in 24.97 seconds with method ai, depth 38, and size 707.
Transpiled circuit index 20 (Be2) in 1.07 seconds with method ai, depth 293, and size 1392.
Transpiled circuit index 21 (graph-complete_bipart) in 0.61 seconds with method ai, depth 229, and size 1437.
Transpiled circuit index 22 (all-vib-f2) in 0.57 seconds with method ai, depth 178, and size 964.
Transpiled circuit index 23 (all-vib-cyclo_propene) in 50.89 seconds with method ai, depth 34, and size 1425.
Transpiled circuit index 24 (TSP_Ncity-5) in 1.61 seconds with method ai, depth 171, and size 2020.
Transpiled circuit index 25 (H2) in 6.39 seconds with method ai, depth 1148, and size 5208.
Transpiled circuit index 26 (uuf100-ham) in 3.97 seconds with method ai, depth 376, and size 5048.
Transpiled circuit index 27 (ham-graph-gnp_k-5) in 3.54 seconds with method ai, depth 357, and size 4451.
Transpiled circuit index 28 (tfim) in 1.72 seconds with method ai, depth 216, and size 3026.
Transpiled circuit index 29 (uuf100-ham) in 4.45 seconds with method ai, depth 426, and size 5399.
Transpiled circuit index 30 (flat100-ham) in 7.02 seconds with method ai, depth 86, and size 3108.
Transpiled circuit index 31 (uf100-ham) in 12.85 seconds with method ai, depth 623, and size 8354.
Transpiled circuit index 32 (OH) in 15.19 seconds with method ai, depth 2084, and size 9543.
Transpiled circuit index 33 (HF) in 17.51 seconds with method ai, depth 2063, and size 9446.
Transpiled circuit index 34 (BH) in 15.33 seconds with method ai, depth 2094, and size 9730.
Transpiled circuit index 0 (all-vib-o3) in 0.02 seconds with method rustiq, depth 13, and size 83.
Transpiled circuit index 1 (all-vib-c2h) in 1.11 seconds with method rustiq, depth 2, and size 39.
Transpiled circuit index 2 (all-vib-bh) in 0.01 seconds with method rustiq, depth 3, and size 30.
Transpiled circuit index 3 (all-vib-c2h) in 0.01 seconds with method rustiq, depth 13, and size 79.
Transpiled circuit index 4 (graph-gnp_k-2) in 0.02 seconds with method rustiq, depth 31, and size 131.
Transpiled circuit index 5 (all-vib-fccf) in 0.04 seconds with method rustiq, depth 50, and size 306.
Transpiled circuit index 6 (all-vib-hno) in 14.03 seconds with method rustiq, depth 22, and size 276.
Transpiled circuit index 7 (all-vib-bhf2) in 3.15 seconds with method rustiq, depth 13, and size 155.
Transpiled circuit index 8 (LiH) in 0.03 seconds with method rustiq, depth 54, and size 270.
Transpiled circuit index 9 (uf20-ham) in 0.04 seconds with method rustiq, depth 65, and size 398.
Transpiled circuit index 10 (all-vib-fccf) in 0.16 seconds with method rustiq, depth 41, and size 516.
Transpiled circuit index 11 (all-vib-fccf) in 0.02 seconds with method rustiq, depth 34, and size 189.
Transpiled circuit index 12 (all-vib-ch2) in 0.03 seconds with method rustiq, depth 49, and size 240.
Transpiled circuit index 13 (tfim) in 0.05 seconds with method rustiq, depth 20, and size 366.
Transpiled circuit index 14 (all-vib-cyclo_propene) in 9.08 seconds with method rustiq, depth 16, and size 277.
Transpiled circuit index 15 (graph-gnp_k-4) in 0.04 seconds with method rustiq, depth 116, and size 612.
Transpiled circuit index 16 (all-vib-hc3h2cn) in 13.89 seconds with method rustiq, depth 2, and size 257.
Transpiled circuit index 17 (TSP_Ncity-4) in 0.05 seconds with method rustiq, depth 133, and size 737.
Transpiled circuit index 18 (tfim) in 0.11 seconds with method rustiq, depth 25, and size 680.
Transpiled circuit index 19 (all-vib-h2co) in 27.19 seconds with method rustiq, depth 66, and size 983.
Transpiled circuit index 20 (Be2) in 0.07 seconds with method rustiq, depth 215, and size 1030.
Transpiled circuit index 21 (graph-complete_bipart) in 0.14 seconds with method rustiq, depth 328, and size 1918.
Transpiled circuit index 22 (all-vib-f2) in 0.05 seconds with method rustiq, depth 114, and size 692.
Transpiled circuit index 23 (all-vib-cyclo_propene) in 62.25 seconds with method rustiq, depth 74, and size 2348.
Transpiled circuit index 24 (TSP_Ncity-5) in 0.20 seconds with method rustiq, depth 436, and size 3605.
Transpiled circuit index 25 (H2) in 0.21 seconds with method rustiq, depth 643, and size 3476.
Transpiled circuit index 26 (uuf100-ham) in 0.24 seconds with method rustiq, depth 678, and size 6120.
Transpiled circuit index 27 (ham-graph-gnp_k-5) in 0.22 seconds with method rustiq, depth 588, and size 5241.
Transpiled circuit index 28 (tfim) in 0.34 seconds with method rustiq, depth 340, and size 5901.
Transpiled circuit index 29 (uuf100-ham) in 0.33 seconds with method rustiq, depth 881, and size 7667.
Transpiled circuit index 30 (flat100-ham) in 0.31 seconds with method rustiq, depth 279, and size 4910.
Transpiled circuit index 31 (uf100-ham) in 0.38 seconds with method rustiq, depth 1138, and size 10607.
Transpiled circuit index 32 (OH) in 0.38 seconds with method rustiq, depth 1148, and size 6512.
Transpiled circuit index 33 (HF) in 0.37 seconds with method rustiq, depth 1090, and size 6256.
Transpiled circuit index 34 (BH) in 0.37 seconds with method rustiq, depth 1148, and size 6501.

ตารางสรุปผล (ข้ามการแสดงภาพเนื่องจาก Circuit ที่ได้มีขนาดใหญ่มาก):

summary_ham = (
    results_ham.groupby("method")[["depth", "size", "runtime"]]
    .mean()
    .round(2)
)
print(summary_ham)

results_ham

depth     size  runtime
method
ai      316.86  2181.26     5.97
rustiq  281.94  2268.80     3.86
sabre   337.97  2120.14     3.07

method        qc_name  qc_index  num_qubits  \
0     sabre     all-vib-o3         0           4
1     sabre    all-vib-c2h         1           4
2     sabre     all-vib-bh         2           2
3     sabre    all-vib-c2h         3           3
4     sabre  graph-gnp_k-2         4           4
..      ...            ...       ...         ...
100  rustiq    flat100-ham        30          90
101  rustiq      uf100-ham        31          46
102  rustiq             OH        32          10
103  rustiq             HF        33          10
104  rustiq             BH        34          10

                                               ops  depth   size   runtime
0                    {'rz': 28, 'sx': 24, 'cz': 6}      6     58  0.016597
1            {'rz': 17, 'sx': 16, 'cz': 4, 'x': 2}      2     39  1.102089
2                    {'sx': 14, 'rz': 13, 'cz': 3}      3     30  0.011042
3           {'sx': 46, 'rz': 45, 'cz': 18, 'x': 6}     18    115  0.025816
4           {'sx': 49, 'rz': 47, 'cz': 24, 'x': 9}     24    129  0.023077
..                                             ...    ...    ...       ...
100    {'sx': 2709, 'cz': 1379, 'rz': 817, 'x': 5}    279   4910  0.309448
101   {'sx': 6180, 'cz': 3120, 'rz': 1303, 'x': 4}   1138  10607  0.380977
102  {'sx': 3330, 'cz': 1704, 'rz': 1455, 'x': 23}   1148   6512  0.383564
103  {'sx': 3213, 'cz': 1620, 'rz': 1406, 'x': 17}   1090   6256  0.368578
104  {'sx': 3331, 'cz': 1704, 'rz': 1447, 'x': 19}   1148   6501  0.374822

[105 rows x 8 columns]

แสดงผลประสิทธิภาพตามลำดับดัชนี Circuit:

plot_transpilation_metrics(
    results_ham, "Transpilation Metrics for Hamiltonian Circuits"
)

แสดงเปอร์เซ็นต์ของ Circuit ที่แต่ละวิธีทำได้ดีที่สุด

def analyze_and_plot_best_methods(results, metric):
    """
    Analyze the best-performing methods for a given metric and plot a pie chart.

    Parameters:
        results (DataFrame): The input DataFrame containing method performance data.
        metric (str): The metric to evaluate ("depth" or "size").
    """
    method_counts = Counter()
    for qc_idx, group in results.groupby("qc_index"):
        min_value = group[metric].min()

        # Find all methods that achieved this minimum value
        best_methods = group[group[metric] == min_value]["method"]
        # Update counts for all best methods (handling ties)
        method_counts.update(best_methods)
    best_method_counts = dict(
        sorted(method_counts.items(), key=lambda x: x[1], reverse=True)
    )

    # Print summary
    print(f"Best-performing methods based on {metric}:")
    for method, count in best_method_counts.items():
        print(f"    {method}: {count} circuit(s)")

    # Plot pie chart
    num_methods = len(best_method_counts)
    colors = plt.cm.viridis_r(range(0, 256, 256 // num_methods))
    plt.figure(figsize=(5, 5))
    plt.pie(
        best_method_counts.values(),
        labels=best_method_counts.keys(),
        autopct="%1.1f%%",
        startangle=140,
        wedgeprops={"edgecolor": "black"},
        textprops={"fontsize": 10},
        colors=colors,
    )
    plt.title(
        f"Percentage of Circuits Method Performed Best for {metric.capitalize()}",
        fontsize=12,
        fontweight="bold",
    )
    plt.show()

analyze_and_plot_best_methods(results_ham, "depth")
analyze_and_plot_best_methods(results_ham, "size")

Best-performing methods based on depth:
    ai: 16 circuit(s)
    rustiq: 16 circuit(s)
    sabre: 10 circuit(s)

Best-performing methods based on size:
    sabre: 18 circuit(s)
    rustiq: 14 circuit(s)
    ai: 10 circuit(s)

การวิเคราะห์ผลการคอมไพล์ Circuit Hamiltonian

ในส่วนนี้ เราประเมินประสิทธิภาพของวิธี Transpile สามวิธี ได้แก่ SABRE, Transpiler ที่ขับเคลื่อนด้วย AI และ Rustiq บน Circuit ควอนตัมที่สร้างด้วย PauliEvolutionGate ซึ่งใช้กันทั่วไปในงานจำลอง Hamiltonian

Rustiq ทำได้ดีที่สุดโดยเฉลี่ยในแง่ของ depth ของ Circuit** โดยได้ depth ต่ำกว่า SABRE ประมาณ 20% ซึ่งเป็นไปตามคาด เนื่องจาก Rustiq ถูกออกแบบมาเป็นพิเศษเพื่อสังเคราะห์การดำเนินการ PauliEvolutionGate ด้วยกลยุทธ์การแตกย่อยที่มี depth ต่ำ ยิ่งไปกว่านั้น กราฟ depth แสดงให้เห็นว่าเมื่อ Circuit ขยายขนาดและความซับซ้อน Rustiq ขยายตัวได้ดีที่สุด โดยรักษา depth ให้ต่ำกว่าทั้ง AI และ SABRE อย่างมีนัยสำคัญในกรณี Circuit ขนาดใหญ่

Transpiler แบบ AI แสดงประสิทธิภาพที่แข็งแกร่งและสม่ำเสมอด้านความลึกของ Circuit โดยทำได้ดีกว่า SABRE อย่างต่อเนื่องในเกือบทุก Circuit อย่างไรก็ตาม มีเวลา Runtime สูงสุด โดยเฉพาะบน Circuit ขนาดใหญ่ ซึ่งอาจจำกัดความเป็นจริงในงานที่ต้องการความเร็วสูง ความสามารถในการขยายตัวด้าน Runtime ยังคงเป็นข้อจำกัดสำคัญ แม้ว่าจะให้การปรับปรุงด้าน depth ที่ดีก็ตาม

SABRE แม้ว่าจะมี depth เฉลี่ยสูงสุด แต่ได้จำนวน Gate เฉลี่ยต่ำสุด ตามมาด้วย Transpiler แบบ AI อย่างใกล้ชิด สิ่งนี้สอดคล้องกับการออกแบบ Heuristic ของ SABRE ที่มุ่งลดจำนวน Gate โดยตรง Rustiq แม้มีความแข็งแกร่งในการลด depth แต่มีจำนวน Gate เฉลี่ยสูงสุด ซึ่งเป็นการแลกเปลี่ยนที่ต้องพิจารณาในแอปพลิเคชันที่ขนาด Circuit สำคัญกว่าระยะเวลา Circuit

สรุป

แม้ว่าโดยทั่วไป Transpiler แบบ AI จะให้ผลลัพธ์ที่ดีกว่า SABRE โดยเฉพาะในด้านความลึกของ Circuit แต่ข้อสรุปไม่ควรเป็นแค่ "ใช้ Transpiler แบบ AI เสมอ" มีความแตกต่างที่สำคัญที่ต้องพิจารณา:

• Transpiler แบบ AI โดยทั่วไปเชื่อถือได้และให้ Circuit ที่ปรับ depth ให้เหมาะสม แต่มาพร้อมกับการแลกเปลี่ยนด้าน Runtime และยังมีข้อจำกัดอื่น ๆ รวมถึง Coupling Map ที่รองรับและความสามารถในการสังเคราะห์ รายละเอียดอยู่ใน เอกสาร Qiskit Transpiler Service

• ในบางกรณี โดยเฉพาะกับ Circuit ขนาดใหญ่มากหรือ Circuit เฉพาะ Hardware Transpiler แบบ AI อาจไม่ได้ผลดีนัก ในกรณีเหล่านี้ Transpiler SABRE เริ่มต้นยังคงเชื่อถือได้อย่างมากและสามารถปรับให้เหมาะสมเพิ่มเติมได้โดยการปรับพารามิเตอร์ (ดู บทเรียนการปรับ SABRE ให้เหมาะสม)

• สิ่งสำคัญคือต้องพิจารณาโครงสร้างของ Circuit เมื่อเลือกวิธี ตัวอย่างเช่น rustiq ถูกสร้างมาเป็นพิเศษสำหรับ Circuit ที่เกี่ยวข้องกับ PauliEvolutionGate และมักให้ประสิทธิภาพดีที่สุดสำหรับปัญหาการจำลอง Hamiltonian

คำแนะนำ:

ไม่มีกลยุทธ์การ Transpile ที่เหมาะกับทุกสถานการณ์ ผู้ใช้ควรทำความเข้าใจโครงสร้างของ Circuit และทดสอบวิธี Transpile หลายวิธี ทั้ง AI, SABRE และเครื่องมือเฉพาะทางอย่าง Rustiq เพื่อหาโซลูชันที่มีประสิทธิภาพสูงสุดสำหรับปัญหาและข้อจำกัด Hardware เฉพาะของตน

ขั้นตอนที่ 3: รันด้วย Qiskit Primitives

เนื่องจากบทเรียนนี้มุ่งเน้นที่การ Transpile จึงไม่มีการทดลองรันบนอุปกรณ์ควอนตัม เป้าหมายคือการใช้ประโยชน์จากการปรับให้เหมาะสมจากขั้นตอนที่ 2 เพื่อให้ได้ Circuit ที่ผ่านการ Transpile แล้วที่มี depth และจำนวน Gate ลดลง

ขั้นตอนที่ 4: ประมวลผลหลังการรันและส่งคืนผลลัพธ์ในรูปแบบคลาสสิกที่ต้องการ

เนื่องจากไม่มีการรันใน Notebook นี้ จึงไม่มีผลลัพธ์ที่ต้องประมวลผลหลังการรัน

เอกสารอ้างอิง

[1] "LightSABRE: A Lightweight and Enhanced SABRE Algorithm". H. Zou, M. Treinish, K. Hartman, A. Ivrii, J. Lishman et al. https://arxiv.org/abs/2409.08368

[2] "Practical and efficient quantum circuit synthesis and transpiling with Reinforcement Learning". D. Kremer, V. Villar, H. Paik, I. Duran, I. Faro, J. Cruz-Benito et al. https://arxiv.org/abs/2405.13196

[3] "Pauli Network Circuit Synthesis with Reinforcement Learning". A. Dubal, D. Kremer, S. Martiel, V. Villar, D. Wang, J. Cruz-Benito et al. https://arxiv.org/abs/2503.14448