מעברי Transpiler מבוססי בינה מלאכותית

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"qiskit": "qiskit", "qiskit_ibm_runtime": "qiskit-ibm-runtime", "qiskit_ibm_transpiler": "qiskit-ibm-transpiler"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

מעברי ה-transpiler מבוססי הבינה המלאכותית הם מעברים שפועלים כתחליף ישיר (drop-in replacement) למעברי Qiskit "מסורתיים" עבור חלק ממשימות ה-transpiling. הם לרוב מפיקים תוצאות טובות יותר מאלגוריתמים היוריסטיים קיימים (כגון עומק נמוך יותר ומספר CNOT נמוך יותר), אך הם גם הרבה יותר מהירים מאלגוריתמי אופטימיזציה כגון פותרי סיפוקיות בוליאנית (Boolean satisfiability). מעברי ה-transpiler מבוססי הבינה המלאכותית רצים בסביבה המקומית שלך.

הערה

מעברי ה-Transpiler מבוססי הבינה המלאכותית נמצאים במצב שחרור בטא, וכפופים לשינויים. אם יש לך משוב או שברצונך ליצור קשר עם צוות המפתחים, השתמש בערוץ סביבת העבודה של Qiskit ב-Slack הזה.

המעברים הבאים זמינים כעת:

מעברי ניתוב

• AIRouting: בחירת layout וניתוב מעגלים

מעברי סינתזת מעגלים

• AICliffordSynthesis: סינתזת מעגלי Clifford
• AILinearFunctionSynthesis: סינתזת מעגלי פונקציה לינארית
• AIPermutationSynthesis: סינתזת מעגלי תמורה

כדי להשתמש במעברי ה-transpiler מבוססי הבינה המלאכותית, יש להתקין תחילה את חבילת qiskit-ibm-transpiler. יש לבקר ב-תיעוד ה-API של qiskit-ibm-transpiler לקבלת מידע נוסף על האפשרויות השונות הזמינות.

pip install qiskit-ibm-transpiler

מעבר AI Routing

המעבר AIRouting משמש גם כשלב פריסה (layout) וגם כשלב ניתוב (routing). ניתן להשתמש בו בתוך 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
import logging

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

circuit = efficient_su2(101, entanglement="circular", reps=1)
logging.getLogger(
    "qiskit_ibm_transpiler.wrappers.ai_local_synthesis"
).setLevel(logging.WARNING)
transpiled_circuit = ai_passmanager.run(circuit)

כאן, ה-backend קובע עבור איזו מפת צימוד (coupling map) לנתב, ה-optimization_level (1, 2, או 3) קובע את מאמץ החישוב שיושקע בתהליך (ערך גבוה יותר בדרך כלל נותן תוצאות טובות יותר אך לוקח יותר זמן), וה-layout_mode מציין כיצד לטפל בבחירת הפריסה. ל-layout_mode יש את האפשרויות הבאות:

• keep: זה מכבד את הפריסה שנקבעה על ידי מעברי ה-Transpiler הקודמים (או משתמש בפריסה הטריוויאלית אם לא נקבעה). בדרך כלל משתמשים בו רק כאשר המעגל חייב לרוץ על qubits ספציפיים של המכשיר. לרוב מניב תוצאות גרועות יותר מכיוון שיש לו פחות מרחב לאופטימיזציה.

• improve: זה משתמש בפריסה שנקבעה על ידי מעברי ה-Transpiler הקודמים כנקודת התחלה. שימושי כשיש לך ניחוש ראשוני טוב לפריסה; לדוגמה, עבור מעגלים שנבנו בצורה שמשקפת בערך את מפת הצימוד של המכשיר. שימושי גם אם אתה רוצה לנסות מעברי פריסה ספציפיים אחרים בשילוב עם מעבר AIRouting.

• optimize: זהו מצב ברירת המחדל. עובד הכי טוב עבור מעגלים כלליים שאולי אין לך ניחושי פריסה טובים עבורם. מצב זה מתעלם מבחירות פריסה קודמות.

מעברי סינתזת מעגלים AI

מעברי סינתזת המעגלים של ה-AI מאפשרים לך לבצע אופטימיזציה לחלקים של סוגי מעגלים שונים (Clifford, Linear Function, Permutation, Pauli Network) על ידי סינתוז מחדש שלהם. דרך טיפוסית להשתמש במעבר הסינתזה היא כך:

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.circuit.library import efficient_su2

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

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

transpiled_circuit = ai_passmanager.run(circuit)

הסינתזה מכבדת את מפת הצימוד של המכשיר: ניתן להריץ אותה בבטחה לאחר מעברי ניתוב אחרים מבלי לשבש את המעגל, כך שהמעגל הכולל עדיין יציית למגבלות המכשיר. כברירת מחדל, הסינתזה תחליף את תת-המעגל המקורי רק אם תת-המעגל המסונתז משפר את המקור (כרגע בודק רק ספירת CNOT), אך ניתן לאלץ החלפה תמיד על ידי הגדרת replace_only_if_better=False.

מעברי הסינתזה הבאים זמינים מ-qiskit_ibm_transpiler.ai.synthesis:

• AICliffordSynthesis: סינתזה עבור מעגלי Clifford (בלוקים של שערי H, S, ו-CX). כרגע עבור בלוקים של עד תשעה qubits.

• AILinearFunctionSynthesis: סינתזה עבור מעגלי Linear Function (בלוקים של שערי CX ו-SWAP). כרגע עבור בלוקים של עד תשעה qubits.

• AIPermutationSynthesis: סינתזה עבור מעגלי Permutation (בלוקים של שערי SWAP). כרגע זמין עבור בלוקים של 65, 33, ו-27 qubits.

• AIPauliNetworkSynthesis: סינתזה עבור מעגלי Pauli Network (בלוקים של שערי H, S, SX, CX, RX, RY ו-RZ). כרגע עבור בלוקים של עד שישה qubits.

אנחנו צופים להגדיל בהדרגה את גודל הבלוקים הנתמכים.

כל המעברים משתמשים ב-thread pool כדי לשלוח מספר בקשות במקביל. כברירת מחדל, מספר ה-threads המקסימלי הוא מספר הליבות פלוס ארבע (ערכי ברירת מחדל של אובייקט ה-ThreadPoolExecutor בפייתון). עם זאת, ניתן להגדיר ערך משלך עם הארגומנט max_threads בזמן יצירת המעבר. לדוגמה, השורה הבאה יוצרת את מעבר AILinearFunctionSynthesis, המאפשרת לו להשתמש בלא יותר מ-20 threads.

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

ניתן גם להגדיר את משתנה הסביבה AI_TRANSPILER_MAX_THREADS למספר ה-threads המקסימלי הרצוי, וכל מעברי הסינתזה שיוצרו לאחר מכן ישתמשו בערך זה.

כדי שמעברי הסינתזה של ה-AI יסנתזו תת-מעגל, הוא חייב להתפרס על תת-גרף מחובר של מפת הצימוד (דרך אחת לעשות זאת היא עם מעבר ניתוב לפני איסוף הבלוקים, אך זו אינה הדרך היחידה). מעברי הסינתזה יבדקו אוטומטית שתת-הגרף הספציפי נתמך, ואם לא, יציגו אזהרה וישאירו את תת-המעגל המקורי ללא שינוי.

מעברי האיסוף המותאמים הבאים עבור Cliffords, Linear Functions ו-Permutations שניתן לייבא מ-qiskit_ibm_transpiler.ai.collection גם משלימים את מעברי הסינתזה:

• CollectCliffords: אוסף בלוקי Clifford כאובייקטי Instruction ושומר את תת-המעגל המקורי להשוואה לאחר הסינתזה.

• CollectLinearFunctions: אוסף בלוקים של SWAP ו-CX כאובייקטי LinearFunction ושומר את תת-המעגל המקורי להשוואה לאחר הסינתזה.

• CollectPermutations: אוסף בלוקים של מעגלי SWAP כ-Permutations.

• CollectPauliNetworks: אוסף בלוקי Pauli Network ושומר את תת-המעגל המקורי להשוואה לאחר הסינתזה.

מעברי האיסוף המותאמים הללו מגבילים את גדלי תת-המעגלים שנאספים כך שיהיו נתמכים על ידי מעברי הסינתזה המבוססים על בינה מלאכותית. לכן, מומלץ להשתמש בהם לאחר מעברי הניתוב ולפני מעברי הסינתזה לקבלת אופטימיזציה כוללת טובה יותר.

transpilation היברידי היוריסטי-AI

חבילת qiskit-ibm-transpiler מאפשרת לך להגדיר pass manager היברידי המשלב את הטוב ביותר ממעברי ה-Transpiler ההיוריסטיים של Qiskit ומעברי ה-Transpiler המבוססים על בינה מלאכותית. תכונה זו מתנהגת בצורה דומה לשיטת generate_pass_manager של Qiskit. דרך טיפוסית להשתמש ב-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_kingston")
kingston_coupling_map = backend.coupling_map

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

ai_transpiler_pass_manager = generate_ai_pass_manager(
    coupling_map=kingston_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 - מציין איזו מפת צימוד להשתמש בה עבור ה-transpilation.
• ai_optimization_level - מציין את רמת האופטימיזציה (1-3) לשימוש עבור רכיבי ה-AI של ה-PassManager.
• optimization_level - מציין כמה אופטימיזציה לבצע על המעגל עבור הרכיבים ההיוריסטיים של ה-PassManager.
• ai_layout_mode - מציין כיצד חלק הניתוב של ה-AI ב-PassManager מטפל בפריסה. ראה בסעיף מעבר AI Routing כדי לסקור את אפשרויות התצורה לפרמטר ai_layout_mode זה.

ציטוט

ציטוט אם אתה משתמש בתכונה כלשהי מבוססת בינה מלאכותית מ-qiskit-ibm-transpiler package במחקר שלך, השתמש בציטוט המומלץ הבא:

@misc{2405.13196,
Author = {David Kremer and Victor Villar and Hanhee Paik and Ivan Duran and Ismael Faro and Juan Cruz-Benito},
Title = {Practical and efficient quantum circuit synthesis and transpiling with Reinforcement Learning},
Year = {2024},
Eprint = {arXiv:2405.13196},
}