AI transpiler passes

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

AI transpiler passes คือ passes ที่ทำหน้าที่แทนที่ passes แบบ "ดั้งเดิม" ของ Qiskit สำหรับงาน transpiling บางอย่าง โดยมักให้ผลลัพธ์ที่ดีกว่าอัลกอริทึมฮิวริสติกที่มีอยู่ (เช่น depth ต่ำกว่าและจำนวน CNOT น้อยกว่า) และยังเร็วกว่าอัลกอริทึมการปรับแต่งอย่าง Boolean satisfiability solvers มาก AI transpiler passes สามารถรันได้ในสภาพแวดล้อมเครื่องของตัวเองหรือบนคลาวด์ผ่าน Qiskit Transpiler Service หากเป็นส่วนหนึ่งของ IBM Quantum® Premium Plan, Flex Plan หรือ On-Prem (via IBM Quantum Platform API) Plan

หมายเหตุ

AI transpiler passes อยู่ในสถานะ beta release ซึ่งอาจมีการเปลี่ยนแปลง หากมีข้อเสนอแนะหรือต้องการติดต่อทีมพัฒนา สามารถใช้ Qiskit Slack Workspace channel นี้ได้เลย

passes ที่ใช้งานได้ในปัจจุบันมีดังนี้:

Routing passes

• AIRouting: การเลือก layout และการ routing ของ Circuit

Circuit synthesis passes

• AICliffordSynthesis: การ synthesis ของ Clifford Circuit
• AILinearFunctionSynthesis: การ synthesis ของ Linear Function Circuit
• AIPermutationSynthesis: การ synthesis ของ Permutation Circuit
• AIPauliNetworkSynthesis: การ synthesis ของ Pauli Network Circuit

ในการใช้งาน AI transpiler passes ต้องติดตั้ง package qiskit-ibm-transpiler ก่อน และสามารถดูข้อมูลเพิ่มเติมเกี่ยวกับตัวเลือกต่าง ๆ ได้ที่ qiskit-ibm-transpiler API documentation

รัน AI transpiler passes บนเครื่องหรือบนคลาวด์

ถ้าต้องการใช้ AI transpiler passes ในสภาพแวดล้อมเครื่องของตัวเองแบบฟรี ให้ติดตั้ง qiskit-ibm-transpiler พร้อม dependencies เพิ่มเติมดังนี้:

pip install qiskit-ibm-transpiler[ai-local-mode]

หากไม่มี dependencies เพิ่มเติมเหล่านี้ AI transpiler passes จะรันบนคลาวด์ผ่าน Qiskit Transpiler Service (ใช้งานได้เฉพาะผู้ใช้ IBM Quantum Premium Plan, Flex Plan หรือ On-Prem (via IBM Quantum Platform API) Plan เท่านั้น) เมื่อติดตั้ง dependencies เพิ่มเติมแล้ว โหมดเริ่มต้นในการรัน AI transpiler passes จะใช้เครื่องของตัวเอง

AI routing pass

AIRouting pass ทำหน้าที่ทั้งเป็น layout stage และ routing stage สามารถใช้ภายใน PassManager ได้ดังนี้:

from qiskit.transpiler import PassManager
from qiskit.circuit.library import efficient_su2
from qiskit_ibm_transpiler.ai.routing import AIRouting
from qiskit_ibm_runtime import QiskitRuntimeService

backend = QiskitRuntimeService().backend("ibm_torino")
ai_passmanager = PassManager(
    [
        AIRouting(
            backend=backend,
            optimization_level=2,
            layout_mode="optimize",
            local_mode=True,
        )
    ]
)

circuit = efficient_su2(101, entanglement="circular", reps=1)

transpiled_circuit = ai_passmanager.run(circuit)

ในที่นี้ backend กำหนด coupling map ที่จะใช้ routing, optimization_level (1, 2 หรือ 3) กำหนดความพยายามในการคำนวณที่จะใช้ในกระบวนการ (ค่าสูงกว่ามักให้ผลดีกว่าแต่ใช้เวลานานกว่า) และ layout_mode กำหนดวิธีจัดการการเลือก layout layout_mode มีตัวเลือกดังนี้:

• keep: รักษา layout ที่กำหนดโดย transpiler passes ก่อนหน้า (หรือใช้ trivial layout หากไม่ได้กำหนด) มักใช้เฉพาะเมื่อ Circuit ต้องรันบน qubits เฉพาะของอุปกรณ์ มักให้ผลลัพธ์ที่แย่กว่าเพราะมีพื้นที่สำหรับการปรับแต่งน้อยกว่า
• improve: ใช้ layout ที่กำหนดโดย transpiler passes ก่อนหน้าเป็นจุดเริ่มต้น เหมาะเมื่อมีการเดา layout เริ่มต้นที่ดี เช่น Circuit ที่สร้างขึ้นในลักษณะที่ใกล้เคียงกับ coupling map ของอุปกรณ์ ยังเหมาะหากต้องการลอง layout passes อื่น ๆ ร่วมกับ AIRouting pass
• optimize: นี่คือโหมดเริ่มต้น ทำงานได้ดีที่สุดสำหรับ Circuit ทั่วไปที่อาจไม่มีการเดา layout ที่ดี โหมดนี้จะละเว้นการเลือก layout ก่อนหน้า
• local_mode: flag นี้กำหนดว่า AIRouting pass จะรันที่ไหน ถ้าเป็น False, AIRouting จะรันจากระยะไกลผ่าน Qiskit Transpiler Service ถ้าเป็น True package จะพยายามรัน pass ในสภาพแวดล้อมเครื่องของตัวเอง โดยถ้าไม่พบ dependencies ที่จำเป็นจะ fallback ไปใช้โหมดคลาวด์

AI circuit synthesis passes

AI circuit synthesis passes ช่วยให้ปรับแต่งส่วนต่าง ๆ ของ Circuit ประเภทต่าง ๆ (Clifford, Linear Function, Permutation, Pauli Network) ด้วยการ re-synthesize วิธีทั่วไปในการใช้ synthesis pass มีดังนี้:

from qiskit.transpiler import PassManager

from qiskit_ibm_transpiler.ai.routing import AIRouting
from qiskit_ibm_transpiler.ai.synthesis import AILinearFunctionSynthesis
from qiskit_ibm_transpiler.ai.collection import CollectLinearFunctions
from qiskit_ibm_transpiler.ai.synthesis import AIPauliNetworkSynthesis
from qiskit_ibm_transpiler.ai.collection import CollectPauliNetworks
from qiskit.circuit.library import efficient_su2

ibm_torino = QiskitRuntimeService().backend("ibm_torino")
ai_passmanager = PassManager(
    [
        AIRouting(
            backend=ibm_torino,
            optimization_level=3,
            layout_mode="optimize",
            local_mode=True,
        ),  # Route circuit
        CollectLinearFunctions(),  # Collect Linear Function blocks
        AILinearFunctionSynthesis(
            backend=ibm_torino, local_mode=True
        ),  # Re-synthesize Linear Function blocks
        CollectPauliNetworks(),  # Collect Pauli Networks blocks
        AIPauliNetworkSynthesis(
            backend=ibm_torino, local_mode=True
        ),  # Re-synthesize Pauli Network blocks.
    ]
)

circuit = efficient_su2(10, entanglement="full", reps=1)

transpiled_circuit = ai_passmanager.run(circuit)

การ synthesis จะเคารพ coupling map ของอุปกรณ์ โดยสามารถรันได้อย่างปลอดภัยหลัง routing passes อื่น ๆ โดยไม่รบกวน Circuit ดังนั้น Circuit โดยรวมจะยังคงเป็นไปตามข้อจำกัดของอุปกรณ์ ตามค่าเริ่มต้น การ synthesis จะแทนที่ sub-circuit เดิมเฉพาะเมื่อ sub-circuit ที่ synthesize ได้ดีกว่าเดิม (ปัจจุบันตรวจสอบเฉพาะจำนวน CNOT) แต่สามารถบังคับให้แทนที่เสมอได้โดยตั้งค่า replace_only_if_better=False

synthesis passes ต่อไปนี้สามารถ import ได้จาก qiskit_ibm_transpiler.ai.synthesis:

• AICliffordSynthesis: Synthesis สำหรับ Clifford circuits (บล็อกของ Gate H, S และ CX) ปัจจุบันรองรับสูงสุดเก้า qubit blocks
• AILinearFunctionSynthesis: Synthesis สำหรับ Linear Function circuits (บล็อกของ Gate CX และ SWAP) ปัจจุบันรองรับสูงสุดเก้า qubit blocks
• AIPermutationSynthesis: Synthesis สำหรับ Permutation circuits (บล็อกของ Gate SWAP) ปัจจุบันรองรับ 65, 33 และ 27 qubit blocks
• AIPauliNetworkSynthesis: Synthesis สำหรับ Pauli Network circuits (บล็อกของ Gate H, S, SX, CX, RX, RY และ RZ) ปัจจุบันรองรับสูงสุดหก qubit blocks

เราคาดว่าจะค่อย ๆ เพิ่มขนาดของ blocks ที่รองรับขึ้นเรื่อย ๆ

ทุก passes ใช้ thread pool เพื่อส่งคำขอหลายรายการพร้อมกัน ตามค่าเริ่มต้น จำนวน threads สูงสุดคือจำนวน cores บวกสี่ (ค่าเริ่มต้นของ Python object ThreadPoolExecutor) อย่างไรก็ตาม สามารถกำหนดค่าเองได้ด้วย argument max_threads เมื่อสร้าง pass ตัวอย่างเช่น บรรทัดต่อไปนี้สร้าง AILinearFunctionSynthesis pass ที่ใช้ threads สูงสุด 20 threads

AILinearFunctionSynthesis(backend=ibm_torino, max_threads=20)  # Re-synthesize Linear Function blocks using 20 threads max

ยังสามารถตั้งค่า environment variable AI_TRANSPILER_MAX_THREADS เป็นจำนวน threads สูงสุดที่ต้องการ และ synthesis passes ทั้งหมดที่สร้างขึ้นหลังจากนั้นจะใช้ค่านั้น

เพื่อให้ AI synthesis passes สามารถ synthesize sub-circuit ได้ sub-circuit นั้นต้องอยู่บน connected subgraph ของ coupling map (วิธีหนึ่งคือใช้ routing pass ก่อนเก็บบล็อก แต่ไม่ใช่วิธีเดียว) synthesis passes จะตรวจสอบโดยอัตโนมัติว่า subgraph เฉพาะนั้นได้รับการรองรับหรือไม่ ถ้าไม่รองรับจะแสดง warning และปล่อย sub-circuit เดิมไว้โดยไม่เปลี่ยนแปลง

collection passes แบบกำหนดเองต่อไปนี้สำหรับ Cliffords, Linear Functions และ Permutations ที่ import ได้จาก qiskit_ibm_transpiler.ai.collection ยังทำงานร่วมกับ synthesis passes ได้ด้วย:

• CollectCliffords: เก็บ Clifford blocks เป็น Instruction objects และเก็บ sub-circuit เดิมเพื่อเปรียบเทียบหลัง synthesis
• CollectLinearFunctions: เก็บบล็อกของ SWAP และ CX เป็น LinearFunction objects และเก็บ sub-circuit เดิมเพื่อเปรียบเทียบหลัง synthesis
• CollectPermutations: เก็บบล็อกของ SWAP circuits เป็น Permutations
• CollectPauliNetworks: เก็บ Pauli Network blocks และเก็บ sub-circuit เดิมเพื่อเปรียบเทียบหลัง synthesis

collection passes แบบกำหนดเองเหล่านี้จำกัดขนาดของ sub-circuits ที่เก็บให้รองรับกับ AI synthesis passes ได้ ดังนั้นจึงแนะนำให้ใช้หลัง routing passes และก่อน synthesis passes เพื่อการปรับแต่งโดยรวมที่ดีขึ้น

การ transpile Circuit แบบ Hybrid heuristic-AI

qiskit-ibm-transpiler ช่วยให้กำหนดค่า hybrid pass manager ที่รวมข้อดีของ heuristic ของ Qiskit และ AI transpiler passes เข้าด้วยกัน ฟีเจอร์นี้ทำงานคล้ายกับ Qiskit generate_pass_manager method วิธีทั่วไปในการใช้ generate_ai_pass_manager มีดังนี้:

from qiskit_ibm_transpiler import generate_ai_pass_manager
from qiskit.circuit.library import efficient_su2
from qiskit_ibm_runtime import QiskitRuntimeService

backend = QiskitRuntimeService().backend("ibm_torino")
torino_coupling_map = backend.coupling_map

su2_circuit = efficient_su2(101, entanglement="circular", reps=1)

ai_transpiler_pass_manager = generate_ai_pass_manager(
    coupling_map=torino_coupling_map,
    ai_optimization_level=3,
    optimization_level=3,
    ai_layout_mode="optimize",
)

ai_su2_transpiled_circuit = ai_transpiler_pass_manager.run(su2_circuit)

ตัวเลือกต่อไปนี้ถูกใช้ในตัวอย่างนี้:

• coupling_map - ระบุ coupling map ที่จะใช้สำหรับการ transpilation
• ai_optimization_level - ระบุระดับการปรับแต่ง (1-3) ที่จะใช้สำหรับส่วน AI ของ PassManager
• optimization_level - ระบุปริมาณการปรับแต่งที่จะทำกับ Circuit สำหรับส่วน heuristic ของ PassManager
• ai_layout_mode - ระบุวิธีที่ส่วน AI routing ของ PassManager จัดการ layout ดูที่ส่วน AI routing pass เพื่อตรวจสอบตัวเลือกการกำหนดค่าสำหรับ parameter ai_layout_mode นี้

ขีดจำกัด

ดูที่ Qiskit Transpiler Service documentation เพื่อข้อมูลเพิ่มเติมเกี่ยวกับขีดจำกัดที่ใช้กับ AI transpiler passes

การอ้างอิง

ถ้าใช้ฟีเจอร์ AI จาก Qiskit Transpiler Service ในงานวิจัย ให้ใช้ การอ้างอิงที่แนะนำ