קבלת מידע על Backend עם Qiskit

גרסאות חבילות

הקוד בדף זה פותח תוך שימוש בדרישות הבאות. אנו ממליצים להשתמש בגרסאות אלו או חדשות יותר.

qiskit-ibm-runtime~=0.43.1

דף זה מסביר כיצד להשתמש ב-Qiskit כדי לאתר מידע על ה-backends הזמינים לך.

רשימת Backends

כדי לצפות ב-backends שיש לך גישה אליהם, תוכל לראות רשימה בדף Compute resources, או להשתמש בשיטת QiskitRuntimeService.backends(). שיטה זו מחזירה רשימה של מופעי IBMBackend:

הערות

אם אתה מחובר למופע או אזור ספציפי, או אם אתחלת את השירות עם מופע או אזור ספציפי באמצעות QiskitRuntimeService(), יוחזרו רק ה-backends הזמינים לך באותו מופע או אזור. אחרת, יוחזרו כל ה-backends הזמינים לך בכל מופע ובכל אזור.
רשימת ה-backends המוחזרת עשויה להיות שונה מזו המוצגת בדף Compute resources של IBM Quantum Platform. הרשימה בדף Compute resources מסוננת תמיד לפי האזור שנבחר בראש הדף.

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

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

# Initialize your account
from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

service.backends()

[<IBMBackend('ibm_pittsburgh')>,
 <IBMBackend('ibm_boston')>,
 <IBMBackend('ibm_fez')>,
 <IBMBackend('ibm_miami')>,
 <IBMBackend('ibm_marrakesh')>,
 <IBMBackend('ibm_torino')>,
 <IBMBackend('ibm_kingston')>]

השיטה QiskitRuntimeService.backend() (שים לב שזו צורת יחיד: backend) מקבלת את שם ה-backend כפרמטר קלט ומחזירה מופע IBMBackend המייצג את אותו backend ספציפי:

service.backend("ibm_fez")

<IBMBackend('ibm_fez')>

סינון Backends

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

הקוד הבא מחזיר רק backends העומדים בקריטריונים אלו וזמינים לך במופע הנבחר כרגע:

הם מכשירי קוונטום אמיתיים (simulator=False)
פועלים כרגע (operational=True)
יש להם לפחות 5 Qubits (min_num_qubits=5)

# Optionally pass in an instance, region, or both, to
# further filter the backends.
service = QiskitRuntimeService()

service.backends(simulator=False, operational=True, min_num_qubits=5)

[<IBMBackend('ibm_pittsburgh')>,
 <IBMBackend('ibm_boston')>,
 <IBMBackend('ibm_fez')>,
 <IBMBackend('ibm_miami')>,
 <IBMBackend('ibm_marrakesh')>,
 <IBMBackend('ibm_torino')>,
 <IBMBackend('ibm_kingston')>]

השתמש בארגומנטי מילות המפתח הללו לסינון לפי כל תכונה בתצורת backend (JSON schema) או סטטוס (JSON schema). שיטה דומה היא QiskitRuntimeService.least_busy(), שמקבלת את אותם מסננים כמו backends() אך מחזירה את ה-backend שעומד במסננים ויש לו את מספר המשימות הקטן ביותר בהמתנה בתור:

service.least_busy(operational=True, min_num_qubits=5)

<IBMBackend('ibm_torino')>

מידע סטטי על Backend

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

התא הבא בונה תיאור של backend.

backend = service.backend("ibm_fez")

print(
    f"Name: {backend.name}\n"
    f"Version: {backend.version}\n"
    f"No. of qubits: {backend.num_qubits}\n"
)

Name: ibm_fez
Version: 2
No. of qubits: 156

לרשימה מלאה של תכונות, ראה את תיעוד ה-API של IBMBackend.

Gates ופעולות מקוריות

לכל משפחת מעבד יש ערכת Gates מקורית. כברירת מחדל, ה-QPUs בכל משפחה תומכים רק בהרצת ה-Gates והפעולות הנמצאות בערכה המקורית. לפיכך, כל Gate ב-Circuit חייב להיות מתורגם (על ידי ה-Transpiler) לאלמנטים של ערכה זו.

תוכל לצפות ב-Gates ובפעולות המקוריות של QPU עם Qiskit, או בדף Compute resources של IBM Quantum® Platform.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

for backend in service.backends():
    config = backend.configuration()
    if "simulator" in config.backend_name:
        continue
    print(f"Backend: {config.backend_name}")
    print(f"    Processor type: {config.processor_type}")
    print(f"    Supported instructions:")
    for instruction in config.supported_instructions:
        print(f"        {instruction}")
    print()

מידע דינמי על Backend

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

תכונות Qubit

backend.properties().qubit_property() מחזיר מידע על התכונות הפיזיות של ה-Qubits. הוא מכיל מילון של תכונות שונות של ה-Qubit, כל אחת מלווה בערכה ובחותמת הזמן של הכיול האחרון.

T1 (Relaxation Time): זמן T1 מייצג את משך הזמן הממוצע שבו Qubit נשאר במצב המעורר $|1\rangle$ לפני שהוא דועך למצב הבסיס $|0\rangle$ עקב הרפיית אנרגיה. פרמטר זה משמש לאפיון התנהגות הרפיית האנרגיה של ה-Qubit, ומבוטא ביחידות של שניות (s).
T2 (Dephasing Time): זמן T2 מציין את סקאלת הזמן שבה Qubit שומר על קוהרנטיות פאזה של סופרפוזיציה בין מצבי $|0\rangle$ ו- $|1\rangle$ . הוא מתחשב גם בהרפיית אנרגיה וגם בתהליכי dephasing טהורים, ומספק תובנה לגבי תכונות הקוהרנטיות של ה-Qubit.
frequency: פרמטר זה מציין את התדירות התהודתית של ה-Qubit, המציינת את הפרש האנרגיה בין מצבי $|0\rangle$ ו- $|1\rangle$ , מבוטא בהרץ (Hz).
anharmonicity: Anharmonicity הוא ההפרש באנרגיה בין המצבים המעוררים הראשון והשני של ה-Qubit, גם הוא מבוטא בהרץ (Hz).
readout_error: שגיאת readout מכמתת את ההסתברות הממוצעת למדידה שגויה של מצב Qubit. היא מחושבת בדרך כלל כממוצע של prob_meas0_prep1 ו-prob_meas1_prep0, ומספקת מדד יחיד לנאמנות המדידה.
prob_meas0_prep1: פרמטר זה מציין את ההסתברות למדידת Qubit במצב 0 כאשר הוא היה אמור להיות מוכן במצב $|1\rangle$ , מסומן כ- $P(0 | 1)$ . הוא משקף שגיאות בהכנת מצב ומדידה (SPAM), ובפרט שגיאות מדידה ב-Qubits מוליכי-על.
prob_meas1_prep0: באופן דומה, פרמטר זה מייצג את ההסתברות למדידת Qubit במצב 1 כאשר הוא היה אמור להיות מוכן במצב $|0\rangle$ , מסומן כ- $P(1 | 0)$ . כמו prob_meas0_prep1, הוא משקף שגיאות SPAM, כאשר שגיאות מדידה הן התורמות הדומיננטיות ב-Qubits מוליכי-על.
readout_length: readout_length מציין את משך פעולת ה-readout עבור Qubit. הוא מודד את הזמן מתחילת דופק המדידה ועד להשלמת דיגיטציית האות, שלאחריה המערכת מוכנה לפעולה הבאה. הבנת פרמטר זה חיונית לאופטימיזציה של ביצוע ה-Circuit, במיוחד בעת שילוב מדידות mid-circuit.

# fundamental physical properties of qubit 1
backend.qubit_properties(1)

QubitProperties(t1=0.00023160183954439313, t2=0.0002759670226087048, frequency=None)

# calibration data with detailed properties of qubit 0
backend.properties().qubit_property(0)

{'T1': (5.199156952582205e-05,
  datetime.datetime(2026, 1, 14, 16, 18, 26, tzinfo=tzlocal())),
 'T2': (2.253552085985709e-05,
  datetime.datetime(2026, 1, 14, 16, 19, 6, tzinfo=tzlocal())),
 'readout_error': (0.013916015625,
  datetime.datetime(2026, 1, 14, 21, 38, 31, tzinfo=tzlocal())),
 'prob_meas0_prep1': (0.026123046875,
  datetime.datetime(2026, 1, 14, 21, 38, 31, tzinfo=tzlocal())),
 'prob_meas1_prep0': (0.001708984375,
  datetime.datetime(2026, 1, 14, 21, 38, 31, tzinfo=tzlocal())),
 'readout_length': (1.56e-06,
  datetime.datetime(2026, 1, 14, 21, 38, 31, tzinfo=tzlocal()))}

# Retrieve qubit properties
qubit_index = 126  # Replace with your qubit index
qubit_props = backend.properties().qubit_property(qubit_index)

# Access specific properties
t1 = qubit_props.get("T1", (None,))[0]
t2 = qubit_props.get("T2", (None,))[0]
frequency = qubit_props.get("frequency", (None,))[0]
anharmonicity = qubit_props.get("anharmonicity", (None,))[0]
readout_error = qubit_props.get("readout_error", (None,))[0]
prob_meas0_prep1 = qubit_props.get("prob_meas0_prep1", (None,))[0]
prob_meas1_prep0 = qubit_props.get("prob_meas1_prep0", (None,))[0]
readout_length = qubit_props.get("readout_length", (None,))[0]

print(f"Qubit {qubit_index} Properties:")
print(f"  T1: {t1} seconds")
print(f"  T2: {t2} seconds")
print(f"  Frequency: {frequency} Hz")
print(f"  Anharmonicity: {anharmonicity} Hz")
print(f"  Readout Error: {readout_error}")
print(f"  P(0 | 1): {prob_meas0_prep1}")
print(f"  P(1 | 0): {prob_meas1_prep0}")
print(f"  Readout Length: {readout_length} seconds")

Qubit 126 Properties:
  T1: 9.563335658857979e-05 seconds
  T2: 6.570556299807121e-05 seconds
  Frequency: None Hz
  Anharmonicity: None Hz
  Readout Error: 0.006591796875
  P(0 | 1): 0.009765625
  P(1 | 0): 0.00341796875
  Readout Length: 1.56e-06 seconds

תכונות הוראה

התכונה backend.target היא אובייקט qiskit.transpiler.Target: אובייקט המכיל את כל המידע הדרוש לביצוע Transpile של Circuit עבור אותו backend. זה כולל שגיאות הוראות ומשכים. לדוגמה, התא הבא מקבל את התכונות עבור Gate cz הפועל בין Qubits 1 ו-0.

backend.target["cz"][(1, 0)]

InstructionProperties(duration=6.8e-08, error=0.007831625819164134)

התא הבא מציג את התכונות עבור פעולת מדידה (כולל שגיאת readout) על Qubit 0.

backend.target["measure"][(0,)]

InstructionProperties(duration=1.56e-06, error=0.013916015625)

הצעדים הבאים

המלצות

נסה את המדריך אלגוריתם גרובר.
עיין בתיעוד QiskitRuntime backend API.

רשימת Backends​

סינון Backends​

מידע סטטי על Backend​

Gates ופעולות מקוריות​

מידע דינמי על Backend​

תכונות Qubit​

תכונות הוראה​

הצעדים הבאים​