צפייה בפרטי Backend

Package versions

The code on this page was developed using the following requirements. We recommend using these versions or newer.

qiskit-ibm-runtime~=0.46.1

דף זה מסביר כיצד למצוא מידע על ה-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

Use the QiskitRuntimeService.backends() method, as shown in the next code block. This method returns a list of IBMBackend instances.

To run the following code, be sure you have already authenticated to the service. See Set up your IBM Cloud account for more details.

To search for a specific backend, use the QiskitRuntimeService.backend() method (note that this is singular: backend), which takes the name of the backend as the input parameter and returns an IBMBackend instance representing that particular backend:

# 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_boston')>,
 <IBMBackend('ibm_pittsburgh')>,
 <IBMBackend('ibm_fez')>,
 <IBMBackend('ibm_marrakesh')>,
 <IBMBackend('ibm_kingston')>,
 <IBMBackend('ibm_miami')>]

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_boston')>,
 <IBMBackend('ibm_pittsburgh')>,
 <IBMBackend('ibm_fez')>,
 <IBMBackend('ibm_marrakesh')>,
 <IBMBackend('ibm_kingston')>,
 <IBMBackend('ibm_miami')>]

הערה

If you are logged in to a specific instance or region, or if you initialized the service with a specific instance or region by using QiskitRuntimeService(), only the backends available to you on that instance or region are returned.

סינון Backends

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

You can filter the available backends by their configuration or status. For more general filters, set the filters argument to a function that accepts a backend object and returns True if it meets your criteria. Refer to the API documentation for more details.

The following code returns only backends that fit these criteria and are available to you on your currently selected instance:

Are real quantum devices (simulator=False)
Are currently operational (operational=True)
Have at least a hundred qubits (min_num_qubits=100)

A similar method is QiskitRuntimeService.least_busy(), which takes the same filters as backends() but returns the backend that matches the filters and has the least number of jobs pending in the queue:

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.backend("ibm_fez")

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

Name: ibm_fez
Version: 1.3.37
No. of 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`, `ID`, `delay`
שערי דו-Qubit	`CZ`, `ECR`
שערים שברירים	`RX` (חד-Qubit), `RZZ` (דו-Qubit)
הוראות לא-יוניטריות	`measure`, `reset`, `measure_*`, `delay`
בקרת זרימה	`if_else` (משוב קלאסי)

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
backend = service.backend("ibm_kingston")

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).

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

T2 (Dephasing time)

זמן $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.backend("ibm_fez")

backend.qubit_properties(1)

QubitProperties(t1=0.00018243651954462543, t2=0.00020405172321184844, frequency=None)

# 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]
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")

Qubit 126 Properties:
  T1: 0.0001248478211384773 seconds
  T2: 7.96150033446492e-05 seconds
  Readout Error: 0.0244140625
  P(0 | 1): 0.029052734375
  P(1 | 0): 0.019775390625
  Readout Length: 1.56e-06 seconds

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

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

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

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

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

prob-meas0-prep1

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

View with Qiskit	`backend.properties().qubit_property(<qubit>, 'prob_meas0_prep1')`
View on IBM Quantum Platform	Calibration data section, Qubit dropdown menu

prob-meas1-prep0

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

View with Qiskit	`backend.properties().qubit_property(<qubit>, 'prob_meas0_prep0')`
View on IBM Quantum Platform	Calibration data section, Qubit dropdown menu

2Q error (Heron and Nighthawk: CZ, Eagle: ECR)

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

View with Qiskit	`backend.target['<instruction>'][<qubit 1>, <qubit 2>]`
View on IBM Quantum Platform	Calibration section: hover over the qubit connection in Map view, or find the value in Table view under the CZ error (Heron and Nighthawk) or ECR error (Eagle) column; find the value for 2Q error (best) in the Details section

Median 2Q error (Heron: CZ, Eagle: ECR)

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

Calculate with Qiskit	Follow the example in this Qiskit Community GitHub notebook
View on IBM Quantum Platform	Details section; also find per-edge data in the Calibration data section

2Q error (layered)

שגיאה ממוצעת לשער בשכבות (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 כולל סעיף בשם שגיאת שער דו-Qubit (בשכבות), המספק את התצוגה המורחבת של שגיאת שער הדו-Qubit הנמוכה ביותר (בשכבות) הנמדדת כפונקציה של מספר ה-Qubit בשרשרת. הערך הסופי, באורך שרשרת 100, הוא הערך המוצג בסעיף הפרטים. בפועל, שש שרשראות של 100 Qubit (שנבחרו מראש על בסיס ביצועים אופטימליים צפויים) נמדדות, והערך המדווח עבור מספר Qubit N הוא השגיאה הנמוכה ביותר שנמצאה בתת-שרשרת באורך N תוך חיפוש על פני שש שרשראות ה-100 Qubit.

Calculate with Qiskit	Follow the example in this Qiskit Community GitHub notebook
View on IBM Quantum Platform	Details section, and an expanded view in the Two-qubit gate error (layered) section

RZZ error (Heron)

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

View with Qiskit	Important: Be sure you have set `use_fractional_gates=True` when you load the backend, then you can use `backend.target['rzz'][<qubit 1>, <qubit 2>]`
View on IBM Quantum Platform	Calibration section: Select RZZ in the Connection dropdown menu and hover over the qubit connection in Map view. You can also select RZZ error in the Graph output dropdown menu in Graph view, or find the value in Table view under the RZZ error column

ID error / √x (sx) error / Pauli-X error / RX error

שגיאה בשערי חד-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, ומניחים שהשגיאות שלהם זהות.

View on IBM Quantum Platform	Details section

Z-axis rotation (RZ) error

שגיאה בשער ה-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, ומספקת מדד יחיד לנאמנות המדידה.

View with Qiskit	`backend.properties().readout_error(<qubit>)`
View on IBM Quantum Platform	Calibration data section, Qubit dropdown menu

Readout error (median)

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

View on IBM Quantum Platform	Calibration data section, Details section

Single-qubit gate length

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

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

Gate length (2Q gates)

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

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

Readout length

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

View with Qiskit	For `measure`: `backend.properties().readout_length(<qubit>)` For `measure_2`: `backend.target['measure_2'][<qubit 1>, ].duration`
View on IBM Quantum Platform	Calibration data section, Qubit dropdown menu

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

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

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

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

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

CLOPS (or CLOPS_h)

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

Calculate with Qiskit	Find the CLOPS code in the Qiskit Community GitHub
View on IBM Quantum Platform	Details section

Status

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

View with Qiskit	`print(backend.status().status_msg)`, `print(backend.status().pending_jobs)`
View on IBM Quantum Platform	Details section

Topology diagram or 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​

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

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

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

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