Orbit - פונקציית Qiskit מבית Quantum Elements

ראה את מסמכי ה-API

הערה

Qiskit Functions היא תכונה ניסיונית הזמינה רק למשתמשי IBM Quantum® בתוכניות Premium Plan, Flex Plan ו-On-Prem (דרך IBM Quantum Platform API). התכונה נמצאת בסטטוס preview ועשויה להשתנות.

סקירה כללית

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

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

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

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

תיאור

Orbit מיועדת לשפר את ביצוע המעגלים הקוונטיים על backends של IBM Quantum. במצב אוטומטי, משתמשים יכולים ליישם בצורה חלקה רצפי DD חזקים מסדר גבוה מבלי לבחור או להגדיר אותם ידנית. משתמשים מתקדמים יכולים במקום זאת להתנסות ברצפים מסדר גבוה יותר הזמינים כדי לזהות ולמטב את הגישה שמספקת את הביצועים הטובים ביותר עבור מעגל ספציפי.

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

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

זרימת עבודה מעשית של Orbit היא:

1. הגדר מעגל קוונטי ובחר את Orbit דרך קטלוג פונקציות Qiskit.

2. כלול את המעגל ללא Orbit באמצעות מצב 'Raw' כדי לקבוע קו בסיס למעגל גולמי.

3. בחר אילו אסטרטגיות אופטימיזציה ליישם, כולל רצפי DD אוטומטיים או שנבחרו על ידי המשתמש, MEM, וטרנספילציה מותאמת.

4. הפעל או השבת שיטות בודדות, או שלח תצורות מרובות, כדי להעריך את ההשפעות הנפרדות והמשולבות שלהן.

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

במבט קדימה אל עידן העמידות לתקלות, Orbit תואמת גם לזרימות עבודה של מחשוב קוונטי עמיד לתקלות, שכן ניתן לשלבה בצורה חלקה עם תיקון שגיאות קוונטי. לטווח ארוך, Orbit מצביעה לעבר פריקת צימוד דינמית ברמה לוגית [1] כדרך עתידית להגנה על קיוביטים לוגיים. בדוגמה שלהלן, שני קיוביטים לוגיים שוזרו כדי ליצור מצב בל לוגי תחת גילוי שגיאות קוונטי. גילוי שגיאות קוונטי לבדו גרם לנאמנות מצב הבל להתדרדר לכ-44% על פני עשרות מיקרו-שניות, בעוד ש-QED בשילוב עם הגנה בסגנון Orbit שמרה על נאמנות מצב הבל הלוגי קרוב לראש הסולם, והגיעה לכ-95.3% באותו חלון זמן.

אמות מידה (Benchmarks)

התוצאות הבאות מסכמות הרצות Orbit נציגות על חומרת IBM Quantum. כמו בבנצ'מרקים אחרים של חומרה, התוצאות תלויות בהתקן שנבחר, מצב הכיול, המעגל והגדרות הביצוע.

דוגמה	מדד	קיוביטים	QPU	פרטים נוספים	שיפור Orbit
ברנשטיין–וזירני	נאמנות מחרוזת-ביטים חבויה	26 60 70	Heron r3	Raw לעומת Full Orbit, טרנספילציה בלבד לעומת Full Orbit, Full Orbit בלבד	75x 66x N/A
QFT (יוניטרי)	נאמנות	10	Heron r2 Heron r3	Orbit לעומת גולמי: ~44% לעומת ~35% ~67% לעומת ~61%	1.26x 1.09x
QFT (מעגלים דינמיים)	נאמנות	10 20	Heron r3	Orbit לעומת גולמי: ~55% לעומת ~2% ~10% לעומת ~0%	27.51x N/A
מצב בל ארוך-טווח (מעגלים דינמיים)	נאמנות	30 60	Heron r2	N/A	1.78x 1.11x
קוד משטח (סריג מרובע)	הסתברות שגיאה לוגית	25	Nighthawk r1	סבב 1 5 סבבים 10 סבבים	1.01x 1.15x 1.12x
קוד משטח (חלת דבש כבדה)	הסתברות שגיאה לוגית	65	Heron r3	סבב 1 5 סבבים 10 סבבים	4.11x 2.04x 1.39x
VQE	שגיאה מוחלטת ביחס לאנרגיה האידיאלית	8	Heron r3	Orbit לעומת גולמי: 56mHa לעומת 1342 mHa	24x
QAOA	הסתברות הצלחה	5	Heron r2	N/A	1.46x
קוד [[4,2,2]] (דיכוי שגיאות ברמה לוגית)	נאמנות מצב בל לוגי משוזר	4	Heron r2	נאמנות ממוצעת על פני 55 μs	1.63x

הגדרות מדדים

• נאמנות מחרוזת-ביטים חבויה של ברנשטיין–וזירני: הסתברות למדידת מחרוזת הביטים החבויה הנכונה. מדד זה מציין עד כמה האלגוריתם משחזר בצורה אמינה את הפתרון המיועד ככל שגודל המעגל גדל. הטבלה מדווחת את שלוש מחרוזות הביטים החבויות הגדולות ביותר שהוערכו בהצלחה תחת שלוש תצורות שונות: (i), מעגלים גולמיים ללא Orbit, שהגיעו ל-26 קיוביטים; (ii), מעגלים עם טרנספילציה בלבד, שהגיעו ל-60 קיוביטים; ו-(iii), מעגלים המשתמשים בזרימת העבודה המלאה של Orbit, שהגיעו ל-70 קיוביטים. עבור המעגלים הגולמיים (i), גורם השיפור מייצג את השיפור בביצועים שהושג על ידי DD ו-MEM ביחס למעגלים שלא שונו. עבור תצורת הטרנספילציה בלבד (ii), הוא מייצג את השיפור שהושג על ידי הוספת DD ו-MEM למעגלים שעברו טרנספילציה אופטימלית. עבור תצורת Orbit המלאה (iii), לא מדווח גורם שיפור בסיס מכיוון שהתקבלה הסתברות הצלחה שאינה אפס רק כאשר כל מרכיבי Orbit (טרנספילציה, DD ו-MEM) היו מופעלים. דוגמה ממחישה מובאת להלן.

• נאמנות טרנספורם פורייה קוונטי: עבור מימושי QFT הן במעגל יוניטרי והן במעגל דינמי [2], הנאמנות מודדת את ההתאמה בין הטרנספורמציה שיושמה בפועל לתהליך QFT האידיאלי על פני 20 מצבי קלט שונים. מעגלים דינמיים מכילים זמן חוסר פעילות משמעותי עקב מדידות באמצע מעגל והזנה קדימה קלאסית, שבמהלכן פריקת צימוד דינמית יכולה לדכא אי-קוהרנטיות. השיפור המדווח משווה את הנאמנות שהתקבלה עם Orbit לנאמנות הגולמית.

• הכנת מצב בל ארוך-טווח: יצירת מצב בל באמצעות מעגלים דינמיים ופעולות הזנה קדימה בין שני קיוביטים המופרדים על ידי עד 60 קיוביטים ביניים, ובכך הדגמת שזירה ארוכת-טווח יעילה על חומרה קוונטית מחוברת מקומית [3]. Orbit מזהה את ניתוב הקיוביט הטוב ביותר, שומרת על הקיוביטים במהלך מדידות הזנה קדימה, ומיישמת MEM כדי להפחית שגיאות קריאה.

• הסתברות שגיאה לוגית של קוד משטח: עבור קוד המשטח מסוג חלת דבש כבדה [4] וקוד המשטח בסריג מרובע [5], בוצעו ניסויי זיכרון קוונטי שבהם מצב לוגי מקודד נשמר על פני סבבים חוזרים של תיקון שגיאות. הסתברות שגיאה לוגית מודדת את ההסתברות ששגיאות מצטברות יגרמו לשחזור שגוי של המידע המקודד (שגיאה נמוכה יותר עדיפה). השיפור המדווח משווה את הסתברות השגיאה הלוגית ממעגלים גולמיים לזו שהתקבלה עם Orbit.

• שגיאה מוחלטת של VQE: שימוש ב-VQE עם ansatz של unitary coupled-cluster ממוטב כדי להעריך את אנרגיית מצב היסוד של LiH [6]. האנרגיה הנמדדת מושווית לאנרגיה האידיאלית המתאימה שהתקבלה מהמעגל חסר הרעש. המדד הוא ההפרש המוחלט בין האנרגיות הנמדדת והאידיאלית (ערכים נמוכים יותר עדיפים). השיפור המדווח הוא:

$$\text{Improvement factor} = \frac{|E_{\mathrm{raw}}-E_{\mathrm{ideal}}|} {|E_{\mathrm{Orbit}}-E_{\mathrm{ideal}}|}.$$

ערכים גדולים מאחד מציינים ש-Orbit מפחיתה את שגיאת האנרגיה ביחס לביצוע ללא פריקת צימוד דינמית.

• הסתברות הצלחה של QAOA: הסתברות למדידת מחרוזת ביטים המתאימה לפתרון אופטימלי של בעיית האופטימיזציה המוגדרת על גרף הפרפר. השיפור המדווח משווה את הסתברות ההצלחה שהתקבלה עם Orbit לזו שהתקבלה מהמעגלים הגולמיים.

• נאמנות לוגית: בניסוי פריקת הצימוד הדינמית הלוגית [[4,2,2]] [1], שני קיוביטים לוגיים קודדו לתוך ארבעה קיוביטים פיזיים והוכנו כמצב בל לוגי משוזר. הנאמנות הלוגית מודדת את ההתאמה בין המצב המקודד המשוחזר לבין מצב הבל הלוגי היעד. השיפור המדווח משווה את הנאמנות הלוגית הממוצעת שהתקבלה עם Orbit וגילוי שגיאות (יכולת הקוד) לזו שהתקבלה בשימוש בקוד לבדו.

התחלת עבודה

התחבר באמצעות מפתח ה-API של IBM Quantum Platform שלך, ובחר את הפונקציה Orbit באופן הבא. קטע קוד זה מניח שכבר שמרת את החשבון שלך בסביבה המקומית שלך.

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

from qiskit_ibm_catalog import QiskitFunctionsCatalog
from qiskit import QuantumCircuit

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")
# Verify that you have access to the function.
catalog.list()

[QiskitFunction(quantum-elements/orbit)]

# Load the function.
orbit = catalog.load("quantum-elements/orbit")

דוגמה

הדוגמה הבאה בונה מעגל ברנשטיין-וזירני ושולחת אותו ל-Orbit בשתי דרכים בעבודה אחת: ביצוע גולמי וברירות מחדל של Orbit.

השתמש בתבנית זו כאשר אתה רוצה השוואה ישירה בין גולמי ל-Orbit.

בניית מעגל ברנשטיין-וזירני

בחר את מחרוזת הביטים החבויה ובנה את המעגל הלוגי. הקיוביט הנוסף הוא יעד האורקל, בעוד שקיוביטי הקלט נמדדים.

def create_bv_circuit(hidden_bitstring: str) -> QuantumCircuit:
    width = len(hidden_bitstring)
    circuit = QuantumCircuit(width + 1, width)

    circuit.x(width)
    circuit.h(range(width + 1))

    for input_qubit, bit in enumerate(reversed(hidden_bitstring)):
        if bit == "1":
            circuit.cx(input_qubit, width)

    circuit.barrier()
    circuit.h(range(width + 1))
    circuit.measure(range(width), range(width))
    return circuit

circuit_width = 50
hidden_bitstring = "1" * circuit_width
shots = 4096

bv_circuit = create_bv_circuit(hidden_bitstring)
bv_circuit.count_ops()

OrderedDict([('h', 102),
             ('cx', 50),
             ('measure', 50),
             ('x', 1),
             ('barrier', 1)])

הכנת עומס העבודה של Orbit

צור PUB אחד של Sampler, ואז שכפל אותו עבור שני מצבי ההשוואה. Orbit מקבלת את המעגל הלוגי וממפה אותו ל-backend שנבחר במהלך הביצוע.

base_pub = (bv_circuit, None, shots)
comparison_labels = ["raw", "orbit"]
pubs = [base_pub] * len(comparison_labels)

הרצת ברירות מחדל של גולמי ו-Orbit

pub_options מקצה את ה-PUB הראשון למצב גולמי, שמדלג על אופטימיזציית Orbit, DD ו-MEM, ומקצה את ה-PUB השני לברירות מחדל של Orbit, שכוללות טרנספילציה מותאמת, הכנסת פריקת צימוד דינמית (DD) אוטומטית, והפחתת שגיאות מדידה (MEM).

backend_name = "ibm_kingston"

job = orbit.run(
    primitive="sampler",
    pubs=pubs,
    backend_name=backend_name,
    options={
        "pub_options": [
            {"mode": "raw"},
            {"mode": "orbit"},
        ],
        "save_backend_info": True,
    },
)

# Check the job ID and status
print(job.job_id)
print(job.status())

c0f1b99c-8dfa-4ebb-9560-d9a37c990acc
QUEUED

קבל את התוצאה והשווה בין המעגלים הגולמי והמשופר על ידי Orbit באמצעות ספירות. עבור תוצאות Sampler, get_counts() על רגיסטר קלאסי שהוחזר מספק את היסטוגרמת הפלט. כאשר MEM מצליח עבור ה-PUB של Orbit, היסטוגרמה זו כבר מתוקנת על ידי MEM; הספירות הבלתי-מתוקנות נשארות זמינות במטא-נתוני Orbit תחת measurementErrorMitigation["rawCounts"].

def extract_counts(pub_result) -> dict[str, int]:
    data = getattr(pub_result, "data", None)
    if data is None:
        raise TypeError("pub_result.data is missing")

    for name in dir(data):
        if name.startswith("_"):
            continue
        register = getattr(data, name)
        get_counts = getattr(register, "get_counts", None)
        if callable(get_counts):
            counts = get_counts()
            if counts:
                return counts

    raise TypeError(
        "No classical register with get_counts() found in pub_result.data"
    )

result = job.result()
if len(result) != len(comparison_labels):
    raise RuntimeError(
        f"Expected {len(comparison_labels)} PUB results, received {len(result)}."
    )

comparison_counts = {
    label: extract_counts(pub_result)
    for label, pub_result in zip(comparison_labels, result, strict=True)
}
correct_counts = {
    label: counts.get(hidden_bitstring, 0)
    for label, counts in comparison_counts.items()
}

print(
    {
        "hidden_bitstring": hidden_bitstring,
        "correct_counts": correct_counts,
        "shots": shots,
    }
)

{'hidden_bitstring': '11111111111111111111111111111111111111111111111111', 'correct_counts': {'raw': 0, 'orbit': 184}, 'shots': 4096}

בצע השוואה חזותית בין המעגלים הגולמי והמשופר על ידי Orbit.

import matplotlib.pyplot as plt

labels = list(correct_counts)
values = list(correct_counts.values())
fig, ax = plt.subplots(figsize=(7, 4))
bars = ax.bar(labels, values, width=0.55)
ax.bar_label(bars, labels=[f"{value:g}" for value in values], padding=3)
ax.set_xlabel("Circuit execution mode")
ax.set_ylabel("Correct hidden-bitstring count")
ax.set_title(f"{circuit_width}-qubit Bernstein-Vazirani on {backend_name}")
ax.set_ylim(0, max(1, 1.15 * max(values)))
ax.grid(axis="y", alpha=0.25)
fig.tight_layout()
plt.show()

קבלת תמיכה

פנה לתמיכה של Quantum Elements: info@quantumelements.ai

הקפד לכלול את המידע הבא:

• מזהה עבודת Qiskit Function (qiskit-ibm-catalog), job.job_id

• שם ה-backend

• pub_options של Orbit שנעשה בהם שימוש עבור המצבים הגולמי ו-Orbit

• תיאור מפורט של הבעיה

• הודעות שגיאה או קודים רלוונטיים כלשהם

• שלבים לשחזור הבעיה

השלבים הבאים

המלצות

• נסה backend שונה, מספר קיוביטים שונה, או מחרוזת ביטים חבויה אחרת.

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

• בקר במסמכי ה-API לתיאור מפורט של כל אפשרויות Orbit.

מקורות

1. דיכוי שגיאות ברמה לוגית בשילוב עם גילוי שגיאות קוונטי, Nature Communications (2026)

2. טרנספורם פורייה קוונטי באמצעות מעגלים דינמיים, Physical Review Letters (2024)

3. שזירה ארוכת-טווח יעילה באמצעות מעגלים דינמיים, PRX Quantum (2024)

4. ניסויי הרחבת קוד משטח על IBM Heron עם קישוריות חלת דבש כבדה, arXiv:2510.18847

5. ניסויי קוד משטח על IBM Nighthawk עם קישוריות סריג מרובע, arXiv:2606.11496

6. מקור בנצ'מרק VQE, Nature Physics (2024)