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

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

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

הערה

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

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

מעברי Routing

• AIRouting: בחירת פריסה (Layout) וניתוב מעגלים (Routing)

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

• AICliffordSynthesis: סינתזה של מעגלי Clifford
• AILinearFunctionSynthesis: סינתזה של מעגלי Linear Function
• AIPermutationSynthesis: סינתזה של מעגלי Permutation כדי להשתמש במעברי ה-AI Transpiler, קודם התקן את חבילת qiskit-ibm-transpiler. כנס לתיעוד ה-API של qiskit-ibm-transpiler לקבלת מידע נוסף על האפשרויות השונות הזמינות.

הרץ את מעברי ה-AI Transpiler מקומית או בענן

קודם התקן את qiskit-ibm-transpiler עם כמה תלויות נוספות כך:

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

לאחר התקנת התלויות הנוספות, מצב ברירת המחדל להרצת מעברי ה-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",
            local_mode=True,
        )
    ]
)

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)

Fetching 4 files:   0%|          | 0/4 [00:00<?, ?it/s]

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

• keep: זה מכבד את הפריסה שנקבעה על ידי מעברי ה-Transpiler הקודמים (או משתמש בפריסה הטריוויאלית אם לא נקבעה). בדרך כלל משתמשים בו רק כאשר המעגל חייב לרוץ על qubits ספציפיים של המכשיר. לרוב מניב תוצאות גרועות יותר מכיוון שיש לו פחות מרחב לאופטימיזציה.
• improve: זה משתמש בפריסה שנקבעה על ידי מעברי ה-Transpiler הקודמים כנקודת התחלה. שימושי כשיש לך ניחוש ראשוני טוב לפריסה; לדוגמה, עבור מעגלים שנבנו בצורה שמשקפת בערך את מפת הצימוד של המכשיר. שימושי גם אם אתה רוצה לנסות מעברי פריסה ספציפיים אחרים בשילוב עם מעבר AIRouting.
• optimize: זהו המצב הברירת מחדל. עובד הכי טוב עבור מעגלים כלליים שאולי אין לך ניחושי פריסה טובים עבורם. מצב זה מתעלם מבחירות פריסה קודמות.
• local_mode: דגל זה קובע היכן רץ מעבר ה-AIRouting. אם False, ה-AIRouting רץ מרחוק דרך שירות Qiskit Transpiler Service. אם True, החבילה מנסה להריץ את המעבר בסביבה המקומית שלך עם נפילה חזרה למצב ענן אם התלויות הנדרשות לא נמצאות.

מעברי סינתזת מעגלים 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)

Fetching 127 files:   0%|          | 0/127 [00:00<?, ?it/s]

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

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

• AICliffordSynthesis: סינתזה עבור מעגלי Clifford (בלוקים של שערי H, S, ו-CX). כרגע עד תשעה בלוקי qubit.
• AILinearFunctionSynthesis: סינתזה עבור מעגלי Linear Function (בלוקים של שערי CX ו-SWAP). כרגע עד תשעה בלוקי qubit.
• AIPermutationSynthesis: סינתזה עבור מעגלי Permutation (בלוקים של שערי SWAP). כרגע זמין עבור בלוקים של 65, 33, ו-27 qubits.
• AIPauliNetworkSynthesis: סינתזה עבור מעגלי Pauli Network (בלוקים של שערי H, S, SX, CX, RX, RY ו-RZ). כרגע עד שישה בלוקי qubit.

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

כל המעברים משתמשים ב-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 Transpiler Service במחקר שלך, השתמש בציטוט המומלץ הבא:

@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},
}