צפייה בפרטי Backend

Package versions

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

qiskit-ibm-runtime~=0.47.0

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

רשום או סנן Backends

רשום את ה-Backends הזמינים לך

ניתן להשתמש ב-Qiskit או ב-IBM Quantum Platform כדי לצפות ברשימת ה-Backends הזמינים לך, או לחפש Backend ספציפי.

שמות QPU

ל-QPUs המתארחים ב-IBM Cloud® יש שמות המתחילים ב-ibm_*. לכל ה-QPUs ניתן שם של עיר - לדוגמה, ibm_kingston. שם זה אינו מציין היכן ה-QPU הפיזי מתארח.

View backends with Qiskit
View backends on IBM Quantum Platform

השתמש בשיטה QiskitRuntimeService.backends(), כפי שמוצג בבלוק הקוד הבא. שיטה זו מחזירה רשימה של מופעי IBMBackend.

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

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

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

_needed = {"qiskit_ibm_runtime": "qiskit-ibm-runtime"}
_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")

# 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_kingston')>]

service.backend("ibm_fez")

<IBMBackend('ibm_fez')>

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

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

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

הערה

אם אתה מחובר למופע או לאזור ספציפיים, או אם אתחלת את השירות עם מופע או אזור ספציפיים באמצעות QiskitRuntimeService(), יוחזרו רק ה-backends הזמינים לך באותו מופע או אזור.

סינון Backends

Filter by properties with Qiskit
Filter by properties on IBM Quantum Platform

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

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

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

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

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

<IBMBackend('ibm_fez')>

מידע סטטי על Backend

חלק מהמידע על Backend אינו משתנה באופן קבוע, כגון שמו, גרסה, מספר ה-Qubit שבו, סוג המעבד שלו (שם משפחת הציפור, המציין את הטופולוגיה וספירת ה-Qubit המשוערת), וסוגי הפיצ'רים שהוא תומך בהם. מידע זה זמין כתכונות של אובייקט ה-backend. לרשימה מלאה של תכונות, ראה את תיעוד ה-API של IBMBackend. מצא מידע נוסף על גרסאות בסעיף גרסאות QPU שלהלן.

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

View backend information with Qiskit
View backend information on IBM Quantum Platform

backend = service.least_busy(operational=True, simulator=False)

print(
    f"Name: {backend.name}\n"
    f"Version: {backend.backend_version}\n"
    f"No. of programmable qubits: {backend.num_qubits}\n"
    f"Processor type: {backend.processor_type}\n"
)

Name: ibm_fez
Version: 1.3.37
No. of programmable qubits: 156
Processor type: {'family': 'Heron', 'revision': '2'}

גרסאות QPU

לכל QPU יש מספר גרסה בצורה X.Y.Z (מייג'ור.מיינור.תיקון). מעגל שקומפל עבור מספר גרסה נתון מובטח לרוץ על אותו QPU. אם מספר התיקון משתנה, המעגל ימשיך לרוץ. אם מספר המייג'ור או המיינור משתנה, המעגל אינו מובטח לרוץ, אם כי ייתכן שיצליח.

מספר גרסת התיקון יגדל עבור תיקונים שאינם שוברים את המעגל המקומפל הקיים.

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

התנאים שבהם מספר הגרסה או התיקון יכול להשתנות מפורטים בטבלה הבאה.

גרסת מייג'ור	גרסת מיינור	גרסת תיקון
החלפת דגימות	מחזורי חימום / קירור	עדכוני תוכנה של QPU
שינויים מהותיים באלקטרוניקת הבקרה	החלפת חלק מהאלקטרוניקה, אם ההחלפה משפיעה מהותית על הפעולה	כיולים ידניים לשיפור נאמנויות
העברת ה-QPU למיקום חדש, אם נובעים מכך שינויי התנהגות משמעותיים	ביטול שער לפרק זמן מסוים עקב בעיות כיול, וכאשר לא ניתן לבצע תיקונים בתוכנה בקלות	שינויים קטנים באלקטרוניקה שאינם משפיעים על הפעולה
	שינוי כיוון שער CNOT

הוראות נתמכות

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

ניתן לצפות בסטי ההוראות הנתמכות עבור QPU באמצעות Qiskit. דף ה-Compute resources של IBM Quantum Platform מפרט רק את שערי היוניטרי הנתמכים (שערי בסיס) עבור QPU.

Find supported instructions with Qiskit
Find basis gates on IBM Quantum Platform

טבלת הוראות נתמכות

קטגוריית פעולה	שם
שערי חד-Qubit	`RZ`, `SX`, `X`, `XSlow`, `ID`, `delay`
שערי דו-Qubit	`CZ`, `ECR`
שערים שבריים	`RX` (חד-Qubit), `RZZ` (דו-Qubit)
הוראות לא-יוניטריות	`measure`, `reset`, `measure_`, `reset_`, `measure_reset*`, `delay`
בקרת זרימה	`if_else` (הזנה קדימה קלאסית)

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)

print(f"Backend: {backend.name}")
print(f"    Processor type: {backend.processor_type}")
print(f"    Supported instructions: {backend.supported_instructions}")

Backend: ibm_kingston

Processor type: {'family': 'Heron', 'revision': '2'}
    Supported instructions: ['cz', 'id', 'delay', 'measure', 'measure_2', 'reset', 'rz', 'sx', 'x', 'if_else', 'store']

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

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

ב-IBM Quantum Platform, ניתן להוריד נתוני כיול כקובץ CSV. לחץ על QPU בדף Compute resources כדי לצפות בכרטיס המידע המפורט שלו, ולאחר מכן לחץ על סמל ההורדה בפינה הימנית העליונה של סעיף נתוני הכיול.

אחזר נתונים היסטוריים

ניתן לאחזר נתוני מאפייני Backend היסטוריים ב-Qiskit באמצעות הקוד הבא:

backend.properties(datetime=<datetime>)

מאפייני qubit

עבור לרשימת מאפייני qubit

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

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

צפייה במאפייני qubit

T1 (Relaxation time)

זמן $T_1$ מייצג את המשך הממוצע שבו qubit נשאר במצב הנרגש שלו $|1\rangle$ לפני שהוא דועך למצב היסוד שלו $|0\rangle$ עקב רלקסציה של אנרגיה. פרמטר זה משמש לאפיון התנהגות רלקסציית האנרגיה של ה-Qubit, ומבוטא ביחידות של שניות (s).

צפייה עם Qiskit	`backend.properties().t1(<qubit>)`
צפייה ב-IBM Quantum Platform	קטע נתוני כיול: תפריט נפתח של Qubit; מצא את הערך של חציון $T_1$ בקטע הפרטים

T2 (זמן דה-פאזה)

זמן $T_2$ מציין את סקאלת הזמן שבה qubit שומר על קוהרנטיות פאזה של סופרפוזיציה בין המצבים $|0\rangle$ ו- $|1\rangle$ . הוא מביא בחשבון הן את רלקסציית האנרגיה והן את תהליכי הדה-פאזה הטהורה, ומספק תובנה לגבי מאפייני הקוהרנטיות של ה-Qubit. $T_2$ מדווח מרצף Hahn echo.

View with Qiskit	`backend.properties().t2(<qubit>)`
View on IBM Quantum Platform	Calibration data section, qubit dropdown menu; find the $T_2$ median value in the Details section

# fundamental physical properties of qubit 1

backend = service.least_busy(operational=True, simulator=False)

backend.qubit_properties(1)

QubitProperties(t1=0.00022010760855770256, t2=0.0002363339150114578, frequency=None)

# Retrieve qubit properties
qubit_index = backend.num_qubits - 1  # 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]
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"  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")

מאפייני הוראה

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

תכונת backend.target היא אובייקט qiskit.transpiler.Target: אובייקט המכיל את כל המידע הנדרש לטרנספילציה של מעגל עבור אותו Backend. זה כולל שגיאות ומשכי הוראות. לדוגמה, התא הבא מקבל את המאפיינים של שער cz הפועל בין זוג qubits מחוברים.

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

צפייה במאפייני הוראה

prob-meas0-prep1

פרמטר זה מציין את ההסתברות למדידת Qubit במצב $|0\rangle$ כאשר הכוונה הייתה להכין אותו במצב $|1\rangle$ , המסומן כ- $P(0 | 1)$ . הוא משקף שגיאות בהכנת מצב ומדידה (SPAM), בפרט שגיאות מדידה ב-Qubit על-מוליך.

צפייה עם Qiskit	`backend.properties().qubit_property(<qubit>, 'prob_meas0_prep1')`
צפייה ב-IBM Quantum Platform	קטע נתוני כיול: תפריט נפתח של קיוביט

prob-meas1-prep0

בדומה לכך, פרמטר זה מייצג את ההסתברות למדידת Qubit במצב $|1\rangle$ כאשר התכוון להכין אותו במצב $|0\rangle$ , המסומן כ- $P(1 | 0)$ . כמו prob_meas0_prep1, הוא משקף שגיאות SPAM, כאשר שגיאות המדידה הן התורם הדומיננטי ב-Qubit על-מוליך.

צפייה עם Qiskit	`backend.properties().qubit_property(<qubit>, 'prob_meas0_prep0')`
צפייה ב-IBM Quantum Platform	בקטע נתוני הכיול: בתפריט הנפתח של הקיוביט

שגיאת 2Q (Heron ו-Nighthawk: CZ, Eagle: ECR)

שגיאת הדו-Qubit לפי קצה מאותה קבוצת מדידות ששימשה לחישוב שגיאת חציון 2Q. שגיאת 2Q (טובה ביותר) מתייחסת לשגיאת הדו-Qubit הנמוכה ביותר בכל קצה של ההתקן, גם מקבוצת מדידות זו.

צפייה עם Qiskit	`backend.target['<instruction>'][<qubit 1>, <qubit 2>]`
צפייה ב-IBM Quantum Platform	קטע כיול: רחף מעל חיבור הקיוביטים בתצוגת מפה, או מצא את הערך בתצוגת טבלה תחת עמודת שגיאת CZ (Heron ו-Nighthawk) או שגיאת ECR (Eagle); מצא את הערך של שגיאת 2Q (הטובה ביותר) בקטע הפרטים

שגיאת 2Q חציונית (Heron: CZ, Eagle: ECR)

נאמנות שער ממוצעת של פעולת הדו-Qubit מ-randomized benchmarking. נמדד ב"בידוד": קבוצות עם הפרדה מינימלית של שני qubit בין קצוות. ה-randomized benchmarking הזה משתמש בשכבות לסירוגין של Cliffords חד-Qubit ושערי דו-Qubit, ולפיכך ערך שגיאת 2Q הסופי כולל את שגיאת שכבת ה-Cliffords חד-Qubit.

חישוב עם Qiskit	עקוב אחר הדוגמה במחברת Qiskit Community GitHub
צפייה ב-IBM Quantum Platform	בקטע הפרטים; אפשר למצוא גם נתונים עבור כל קצה (edge) בקטע נתוני הכיול

שגיאת 2Q (בשכבות)

שגיאה ממוצעת לשער בשכבות (EPLG) בשרשרת של 100 qubit. EPLG ממוצע מודד את שגיאת השער הממוצעת בשרשרת שכבות של $N$ qubit ( $N$ =100 כאן). הוא נגזר מכמות דומה המכונה נאמנות שכבה (LF) כאשר EPLG $_{100}$ = 4/5(1-LF $^{\frac{1}{99}}$ ) ונאמנות השכבה היא נאמנות התהליך של שרשרת השכבות של $N$ qubit. לפרטים, ראה את המאמר Benchmarking quantum processor performance at scale. שים לב שבמאמר EPLG מוגדר עבור שגיאת תהליך, אך לעקביות עם שגיאות השער המדווחות בנפרד כאן הוא מצוטט עבור שגיאת שער ממוצעת, ומכאן הגורם 4/5.

ב-IBM Quantum Platform, כרטיס המידע המפורט של כל QPU כולל מקטע בשם Two-qubit gate error (layered), שמציג את התצוגה המורחבת של ה-two-qubit gate error (layered) הנמוך ביותר שנמדד כפונקציה של מספר הקיוביטים בשרשרת. הערך הסופי, באורך שרשרת 100, הוא הערך שמוצג במקטע Details. בפועל נמדדות שש שרשראות של 100 קיוביטים (שנבחרו מראש על סמך הביצועים האופטימליים הצפויים), והערך המדווח עבור מספר קיוביטים N הוא השגיאה הנמוכה ביותר שנמצאה בתת-שרשרת באורך N בחיפוש על פני שש השרשראות של 100 קיוביטים.

חישוב עם Qiskit	עקוב אחר הדוגמה במחברת Qiskit Community GitHub
צפייה ב-IBM Quantum Platform	בקטע הפרטים, ותצוגה מורחבת בקטע Two-qubit gate error (layered)

שגיאת RZZ (Heron)

שגיאה בשער ה-RZZ, ממוצעת על פני זוויות ה-RZZ, באמצעות גרסה של randomized benchmarking עבור יוניטריים שרירותיים.

צפייה עם Qiskit	חשוב: ודא שהגדרת `use_fractional_gates=True` בעת טעינת ה-Backend, ואז תוכל להשתמש ב-`backend.target['rzz'][<qubit 1>, <qubit 2>]`
צפייה ב-IBM Quantum Platform	קטע כיול: בחר RZZ בתפריט הנפתח Connection ורחף מעל חיבור ה-Qubit בתצוגת Map. אפשר גם לבחור RZZ error בתפריט הנפתח Graph output בתצוגת Graph, או למצוא את הערך בתצוגת Table תחת עמודת RZZ error

שגיאת ID / שגיאת √x (sx) / שגיאת Pauli-X / שגיאת RX

שגיאה בשערי חד-Qubit בדידים בעלי משך סופי, הנמדדת מ-randomized benchmarking. רצף ה-randomized benchmarking כולל שערי SX, ID ו-X, ומניחים שהשגיאות שלהם זהות. שער ה-ID הוא עיכוב שמשכו שווה למשך שערי √X ו-X. שער ה-RX הוא גם באותו משך כמו שערי √X ו-X עם אמפליטודה משתנה, ולפיכך מדווח כבעל אותה שגיאה כמו שערים אלה.

View with Qiskit	`backend.target['<instruction>'][<qubit 1>, ]`
View on IBM Quantum Platform	Calibration section: Qubit dropdown menu

SX error (median)

נאמנות שער ממוצעת של שער √X (SX) מ-randomized benchmarking, נמדד בו-זמנית על כל ה-Qubit. רצף ה-randomized benchmarking כולל שערי SX, ID ו-X, ומניחים שהשגיאות שלהם זהות.

צפייה ב-IBM Quantum Platform	קטע הפרטים

שגיאת סיבוב ציר Z (RZ)

שגיאה בשער ה-RZ הווירטואלי. מדווחת כ-0 עבור כולם, מכיוון שהוא מתבצע בתוכנה.

View with Qiskit	`backend.target['<instruction>'][<qubit 1>, ]`
View on IBM Quantum Platform	Calibration section: Connection dropdown menu

Readout error

שגיאת הקריאה מכמתת את ההסתברות הממוצעת למדידה שגויה של מצב qubit. היא מחושבת בדרך כלל כממוצע של prob_meas0_prep1 ו-prob_meas1_prep0, ומספקת מדד יחיד לנאמנות המדידה.

צפייה עם Qiskit	`backend.properties().readout_error(<qubit>)`
צפייה ב-IBM Quantum Platform	בקטע נתוני הכיול: בתפריט הנפתח של הקיוביט

שגיאת קריאה (חציון)

נאמנות פעולת הקריאה. שגיאת הקריאה נמדדת על ידי הכנת ה-Qubit במצב $|0\rangle$ ( $|1\rangle$ ) ומדידת ההסתברות לפלט במצב $|1\rangle$ ( $|0\rangle$ ). הערך המדווח הוא הממוצע של שתי שגיאות אלה. החציון נלקח על פני כל הקיוביטים.

View on IBM Quantum Platform	Calibration data section: Details section

Single-qubit gate length

משך פעולת שער חד-Qubit. שים לב שהערכים המוצגים ב-IBM Quantum Platform הם בננו-שניות. הערכים המוחזרים ב-Qiskit הם בשניות.

צפייה עם Qiskit	`backend.target['<instruction>'][<qubit 1>, ].duration`
צפייה ב-IBM Quantum Platform	קטע כיול: תפריט נפתח של Qubit

אורך שער (שערי 2Q)

משך הפעולה של שער דו-קיוביטי. שים לב שהערכים המוצגים ב-IBM Quantum Platform הם בננו-שניות. הערכים המוחזרים ב-Qiskit הם בשניות.

צפייה עם Qiskit	`backend.target['<instruction>'][<qubit 1>, <qubit 2> ].duration`
צפייה ב-IBM Quantum Platform	קטע כיול: תפריט נפתח של קיוביט

אורך קריאה

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

צפייה עם Qiskit	עבור `measure`: `backend.properties().readout_length(<qubit>)` עבור `measure_2`: `backend.target['measure_2'][<qubit 1>, ].duration`
צפייה ב-IBM Quantum Platform	בקטע נתוני הכיול: בתפריט הנפתח של הקיוביט

שגיאת אתחול

שגיאת האתחול מכמתת את אחוז האוכלוסייה במצב $|1\rangle$ לאחר השהיית החזרה המחדלית והליך אתחול הקיוביט כאשר הניסוי הקודם הכין את הקיוביט במצב $|1\rangle$ . שים לב שזה שונה במעט מהכמות prob_meas1_prep0, שמודדת את אחוז המדידות שהוקצו למצב $|1\rangle$ . הכמות האחרונה היא מדידה גם של שגיאת האתחול וגם של הליך ההבחנה בין המצבים $|0\rangle$ ו- $|1\rangle$ . בגבול של מדידה מושלמת, שתי הכמויות זהות.

צפייה עם Qiskit	`backend.properties().qubit_property(<qubit>, 'init_error')`
צפייה ב-IBM Quantum Platform	בקטע נתוני הכיול: בתפריט הנפתח של הקיוביט

# Get the cz gate properties for a connected pair of qubits
# (the first edge in this backend's coupling map)
edge = next(iter(backend.target["cz"]))
backend.target["cz"][edge]

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

InstructionProperties(duration=1.66e-06, error=0.0126953125)

מאפיינים נוספים

מספר מעגלים מקסימלי לשנייה (MCPS)

מספר מעגלים מקסימלי לשנייה (MCPS) כולל מדידה, איפוס ואתחול מחדש של מעגל עם שער הדמר ומדידה בודדת.

צפייה עם Qiskit	`mcps = backend.configuration().mcps`
צפייה ב-IBM Quantum Platform	קטע פרטים

CLOPS (או CLOPS_h)

פעולות שכבת מעגל לשנייה (CLOPS) הוא מדד לכמה שכבות של מעגל 100x100 (מעגל מותאם חומרה) QPU יכול לבצע ביחידת זמן.

חישוב עם Qiskit	מצא את קוד ה-CLOPS ב-Qiskit Community GitHub
צפייה ב-IBM Quantum Platform	בקטע הפרטים

סטטוס

עם BackendStatus, ניתן למצוא את סטטוס ה-QPU (לדוגמה, Active, Paused, Offline) וכן את מספר המשימות הממתינות.

צפייה עם Qiskit	`print(backend.status().status_msg)`, `print(backend.status().pending_jobs)`
צפייה ב-IBM Quantum Platform	בקטע הפרטים

תרשים טופולוגיה או מפת צימוד (coupling map)

דיאגרמה המציינת את הזוגות של qubit התומכים בפעולות שערי דו-Qubit ביניהם. זה נקרא גם coupling map או קישוריות. ה-Qubit מיוצגים כעיגולים ופעולות שערי הדו-Qubit הנתמכות מוצגות כקווים המחברים את ה-Qubit.

View with Qiskit	`from qiskit.visualization import plot_gate_map` then `plot_gate_map(backend)`
View on IBM Quantum Platform	Calibration data section; Click on Expand for a larger view

מה משמעות `error = 1`?

אם ה-benchmarking של qubit או קצה לא מצליח במשך מספר ימים, בין אם עקב איכות נתונים ירודה או גורמים פנימיים אחרים, ערך השגיאה המדווח נחשב לישן ויידווח כ-1. אין זה אומר שה-Qubit או הקצה בהכרח אינם פועלים או שהשגיאה היא 1; במקום זאת, השגיאה נחשבת לבלתי-מוגדרת ועליך לנהוג בזהירות בעת תפעול ה-Qubit או השער הזה.

הצעדים הבאים

המלצות

למד כיצד לבנות מודלי רעש לסימולציה קלאסית עם רעש.
עיין בנושא שלבי ה-Transpiler כדי ללמוד כיצד ה-Transpiler משתמש במאפייני Backend לאופטימיזציית מעגלים.
עיין בתיעוד ה-QiskitRuntime backend API.

רשום או סנן Backends​

רשום את ה-Backends הזמינים לך​

סינון Backends​

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

גרסאות QPU​

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

טבלת הוראות נתמכות​

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

מאפייני qubit​

צפייה במאפייני qubit​

מאפייני הוראה​

צפייה במאפייני הוראה​

מאפיינים נוספים​

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