ניהול ביצועים: פונקציית Qiskit מאת Q-CTRL Fire Opal
פונקציות Qiskit הן תכונה ניסיונית הזמינה רק למשתמשי תוכנית IBM Quantum® Premium Plan, Flex Plan ו-On-Prem (דרך IBM Quantum Platform API). הן בסטטוס גרסת תצוגה מקדימה וכפופות לשינויים.
סקירה כללית
Fire Opal Performance Management מאפשרת לכולם להשיג תוצאות משמעותיות ממחשבי קוונטום בקנה מידה גדול, מבלי שיצטרכו להיות מומחי חומרה קוונטית. בעת הרצת Circuit-ים עם Fire Opal Performance Management, טכניקות דיכוי שגיאות מבוססות AI מיושמות אוטומטית, ומאפשרות לדרג בעיות גדולות יותר עם יותר Gate-ים ו-Qubit-ים. גישה זו מצמצמת את מספר ה-shots הנדרשים להגעה לתשובה הנכונה, ללא תקורה נוספת — מה שחוסך זמן חישוב ועלויות משמעותיות.
ניהול ביצועים מדכא שגיאות ומגדיל את ההסתברות לקבל את התשו בה הנכונה על חומרה רועשת. במילים אחרות, הוא מגדיל את יחס האות-לרעש. התמונה הבאה מציגה כיצד הדיוק המשופר שמאפשר ניהול ביצועים יכול לצמצם את הצורך ב-shots נוספים במקרה של אלגוריתם Quantum Fourier Transform עם 10 Qubit-ים. עם 30 shots בלבד, Q-CTRL מגיעה לסף הביטחון של 99%, בעוד ש-Sampler ברירת המחדל (QiskitRuntime Sampler, optimization_level=3 ו-resilience_level=1, ibm_sherbrooke) דורש 170,000 shots. בכך שמגיעים לתשובה הנכונה מהר יותר, חוסכים זמן ריצה חישובי משמעותי.
אפשר להשתמש בפונקציית ניהול הביצועים עם כל אלגוריתם, וניתן לשלב אותה בקלות במקום ה-Qiskit Runtime primitives הסטנדרטיים. מאחורי הקלעים, מספר טכניקות דיכוי שגיאות פועלות יחד כדי למנוע שגיאות בזמן ריצה. כל שיטות ה-pipeline של Fire Opal מוגדרות מראש ואינן תלויות באלגוריתם, כך שתמיד מקבלים את הביצועים הטובים ביותר ישר מהקופסה.
לקבלת גישה לניהול ביצועים, צרו קשר עם Q-CTRL.
תיאור
ל-Fire Opal Performance Management שתי אפשרויות ריצה הדומות ל-Qiskit Runtime primitives, כך שניתן להחליף בקלות את Q-CTRL Sampler ו-Estimator. זרימת העבודה הכללית לשימוש בפונקציית ניהול הביצועים היא:
- הגדירו את ה-Circuit (ואת האופרטורים במקרה של ה-Estimator).
- הריצו את ה-Circuit.
- אחזרו את התוצאות.
כדי לצמצם את הרעש של החומרה, Fire Opal משתמשת במגוון טכניקות דיכוי שגיאות מבוססות AI כפי שמוצג בתמונה הבאה. עם Fire Opal, כל ה-pipeline אוטומטי לחלוטין וללא כל צורך בהגדרות.
ה-pipeline של Fire Opal מבטל את הצורך בתקורה נוספת, כמו זמן ריצה קוונטי מוגדל או Qubit-ים פיזיים נוספים. שימו לב שזמן עיבוד קלאסי עדיין גורם לעלויות (ראו את הקטע מדדי ביצועים לאומדנים, כאשר "Total time" משקף הן עיבוד קלאסי והן קוונטי). בניגוד לתיקון שגיאות, שדורש תקורה בצורת דגימה, דיכוי השגיאות של Fire Opal פועל הן ברמת ה-Gate והן ברמת הפולס כדי לטפל במקורות שונים של רעש ולמנוע את ההסתברות להתרחשות שגיאה. בכך שמונעים שגיאות, מבטלים את הצורך בעיבוד לאחר המדידה יקר.
התמונה הבאה מציגה את שיטות דיכוי השגיאות שמאפשר Fire Opal Performance Management.
הפונקציה מצי עה שני primitives, Sampler ו-Estimator, והקלט והפלט של שניהם מרחיבים את המפרט המיושם עבור Qiskit Runtime V2 primitives.
מדדי ביצועים
תוצאות בנצ'מרקינג אלגוריתמי שפורסמו מדגימות שיפור ביצועים משמעותי על פני אלגוריתמים שונים, כולל Bernstein-Vazirani, Quantum Fourier Transform, חיפוש Grover, אלגוריתם אופטימיזציה קוונטית מקורבת, ו-Variational Quantum Eigensolver. שאר החלק הזה מספק פרטים נוספים על סוגי האלגוריתמים שניתן להריץ, כמו גם את הביצועים וזמני הריצה הצפויים.
המחקרים העצמאיים הבאים מדגימים כיצד ניהול הביצועים של Q-CTRL מאפשר מחקר אלגוריתמי בקנה מידה שובר שיאים:
- Parametrized Energy-Efficient Quantum Kernels for Network Service Fault Diagnosis - למידת גרעין קוונטי עד 50 Qubit-ים
- Tensor-based quantum phase difference estimation for large-scale demonstration - אומדן פאזה קוונטית עד 33 Qubit-ים
- Hierarchical Learning for Quantum ML: Novel Training Technique for Large-Scale Variational Quantum Circuits - טעינת נתונים קוונטית עד 21 Qubit-ים
הטבלה הבאה מספקת מדריך גס לדיוק ולזמני ריצה מריצות בנצ'מרקינג קודמות על ibm_fez. הביצועים על מכשירים אחרים עשויים להשתנות. זמן השימוש מבוסס על הנחה של 10,000 shots לכל Circuit. "מספר ה-Qubit-ים" המצוין אינו מגבלה קשה אלא מייצג סף גס שבו ניתן לצפות לדיוק עקבי מאוד בפתרונות. גדלי בעיות גדולים יותר נפתרו בהצלחה, ובדיקה מעבר למגבלות אלה מוזמנת.
| דוגמה | מספר Qubit-ים | דיוק | מדד דיוק | זמן כולל (שניות) | שימוש ב-Runtime (שניות) | Primitive (מצב) |
|---|---|---|---|---|---|---|
| Bernstein–Vazirani | 50Q | 100% | שיעור הצלחה (אחוז הריצות שבהן התשובה הנכונה היא ה-bitstring בעל הספירה הגבוהה ביותר) | 10 | 8 | Sampler |
| Quantum Fourier Transform | 30Q | 100% | שיעור הצלחה (אחוז הריצות שבהן התשובה הנכונה היא ה-bitstring בעל הספירה הגבוהה ביותר) | 10 | 8 | Sampler |
| Quantum Phase Estimation | 30Q | 99.9998% | דיוק הזווית שנמצאה: 1- abs(real_angle - angle_found)/pi | 10 | 8 | Sampler |
| סימולציה קוונטית: מודל Ising (15 צעדים) | 20Q | 99.775% | (מוגדר למטה) | 60 (לכל צעד) | 15 (לכל צעד) | Estimator |
| סימולציה קוונטית 2: דינמיקה מולקולרית (20 נקודות זמן) | 34Q | 96.78% | (מוגדר למטה) | 10 (לכל נקודת זמן) | 6 (לכל נקודת זמן) | Estimator |
הגדרת דיוק מדידת ערך ציפייה — המדד מוגדר כדלקמן:
כאשר = ערך ציפייה אידיאלי, = ערך ציפייה נמדד, = ערך מקסימלי אידיאלי, ו- = ערך מינימלי אידיאלי. הוא פשוט הממוצע של ערך על פני מדידות מרובות.
מדד זה משמש מפני שהוא אינווריאנטי להזזות גלובליות ולסקלה בטווח הערכים האפשריים. במילים אחרות, בין אם תגבילו את טווח ערכי הציפייה האפשריים למעלה או למטה ובין אם תגדילו את הפריסה, ערך אמור להישאר עקבי.
תחילת עבודה
Fire Opal Performance Management משתמשת ב-Qiskit גרסה 2.0.0, שהיא הגרסה המומלצת. הגרסאות הנתמכות הן Qiskit >=v2.0.0.
אמתו את הזהות שלכם באמצעות מפתח ה-API של IBM Quantum Platform, ובחרו את פונקציית ה-Qiskit כך. (הקטע הזה מניח שכבר שמרתם את החשבון שלכם בסביבה המקומית שלכם.)
# Added by doQumentation — required packages for this notebook
!pip install -q matplotlib numpy qiskit qiskit-ibm-catalog qiskit-ibm-runtime
from qiskit_ibm_catalog import QiskitFunctionsCatalog
catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")
# Access Function
perf_mgmt = catalog.load("q-ctrl/performance-management")
Estimator primitive
דוגמה ל-Estimator
השתמשו ב-Estimator primitive של Fire Opal Performance Management כדי לקבוע את ערך הציפייה של זוג Circuit-observable יחיד.
בנוסף לחבילות qiskit-ibm-catalog ו-qiskit, תשתמשו גם בחבילת numpy להרצת דוגמה זו. ניתן להתקין חבילה זו על ידי ביטול ההערה בתא הבא אם אתם מריצים דוגמה זו ב-notebook באמצעות IPython kernel.
# %pip install numpy
1. יצירת ה-Circuit
כדוגמה, צרו אופרטור Hermitian אקראי ו-observable כקלט לפונקציית ניהול הביצועים.
import numpy as np
from qiskit.circuit.library import iqp
from qiskit.quantum_info import random_hermitian, SparsePauliOp
n_qubits = 50
# Generate a random circuit
mat = np.real(random_hermitian(n_qubits, seed=1234))
circuit = iqp(mat)
circuit.measure_all()
# Define observables as a string
observable = SparsePauliOp("Z" * n_qubits)
# Create PUB tuple
estimator_pubs = [(circuit, observable)]
2. הרצת ה-Circuit
הריצו את ה-Circuit, ובאופן אופציונלי הגדירו את ה-Backend ואת מספר ה-shots.
# This cell is hidden from users
from qiskit_ibm_runtime import QiskitRuntimeService
service = QiskitRuntimeService()
backend_name = service.least_busy().name
# Run the circuit using the estimator
qctrl_estimator_job = perf_mgmt.run(
primitive="estimator",
pubs=estimator_pubs,
backend_name=backend_name,
)
ניתן להשתמש ב-Qiskit Serverless APIs המוכרים לבדיקת סטטוס עומס העבודה של פונקציית ה-Qiskit:
qctrl_estimator_job.status()
'QUEUED'
3. אחזור התוצאה
# Retrieve the counts from the result list
result = qctrl_estimator_job.result()
התוצאות הן באותו פורמט כמו תוצאת Estimator:
print(
f"The result of the submitted job had {len(result)} PUB and has a value:\n {result}\n"
)
print(
f"The associated PubResult of this job has the following DataBins:\n {result[0].data}\n"
)
print(f"And this DataBin has attributes: {result[0].data.keys()}")
print(
f"The expectation values measured from this PUB are: \n{result[0].data.evs}"
)
The result of the submitted job had 1 PUB and has a value:
PrimitiveResult([PubResult(data=DataBin(evs=-0.0035, stds=0.999993874981242), metadata={'precision': None})], metadata={})
The associated PubResult of this job has the following DataBins:
DataBin(evs=-0.0035, stds=0.999993874981242)
And this DataBin has attributes: dict_keys(['evs', 'stds'])
The expectation values measured from this PUB are:
-0.0035
קלטי Estimator
| שם | סוג | תיאור | נדרש | ברירת מחדל | דוגמה |
|---|---|---|---|---|---|
| pubs | QctrlEstimatorPubLike או list[QctrlEstimatorPubLike] | tuple אחד או יותר המכיל את הקלטים המפורטים תחת רכיבי EstimatorPubLike | כן | N/A | (circuit, observables, parameter_values) |
| backend_name | str | שם ה-Backend | לא | ה-Backend הפחות עמוס שיש לו גישה ל-instance שלך | "ibm_fez" |
| options | dict | אפשרויות קלט; ראו את קטע האפשרויות לפרטים נוספים | לא | ראו את קטע האפשרויות לפרטים | {"default_shots": 2048} |
רכיבי QctrlEstimatorPubLike (נגזר מ-הגדרת Qiskit Runtime PUB):
- Circuit יחיד המוגדר כ-
QuantumCircuitאו בפורמט מחרוזת OpenQASM 2.0 או 3.0. - observable אחד או יותר שמציינים את ערכי הציפייה לאמוד, בכל אחד מהפורמטים המצוינים ברשימה "פורמטי observables נתמכים".
- (אופציונלי) אוסף ערכי פרמטרים לקשירה ל-Circuit, שעוקבים אחרי חוקי שידור מערכים של ה-
QiskitRuntimeprimitives. - (אופציונלי) דיוק יעד לערכי ציפייה שיש לאמוד.
- (אופציונלי) מספר ממשי המייצג את הדיוק, או מילון של אפשרויות ריצה המכיל את מספר ה-shots. לדוגמה:
{"shots": <int>}.
פורמטי observables נתמכים:
- כל אחד מפורמטי
ObservablesArrayLike, כמוPauli,SparsePauliOp,PauliList, אוstr - מחרוזת Pauli:
"XY" - מילון — מחרוזות Pauli עם מקדמים:
{"XY": 0.5, "YZ": 0.3} - רשימת מחרוזות Pauli:
["XY", "YZ", "ZX"] - רשימת מחרוזות Pauli עם מקדמים:
[("XY", 0.5), ("YZ", 0.3)] - רשימה מקוננת של מחרוזות Pauli:
[["XY", "YZ"], ["ZX", "XX"]] - רשימה מקוננת של מחרוזות Pauli עם מקדמים:
[[("XY", 0.1), ("YZ", 0.2)], [("ZX", 0.3), ("XX", 0.4)]]
Backend-ים נתמכים: הרשימה הבאה של Backend-ים נתמכת כרגע. אם המכשיר שלכם אינו ברשימה, פנו ל-Q-CTRL כדי להוסיף תמיכה.
service.backends()
[<IBMBackend('ibm_fez')>,
<IBMBackend('ibm_brisbane')>,
<IBMBackend('ibm_pittsburgh')>,
<IBMBackend('ibm_kingston')>,
<IBMBackend('ibm_torino')>,
<IBMBackend('ibm_marrakesh')>]
אפשרויות:
| שם | סוג | תיאור | ברירת מחדל |
|---|---|---|---|
| session_id | str | מזהה Session קיים של Qiskit Runtime | "cw4r3je6f0t010870y3g" |
| default_shots | int | מספר ה-shots לשימוש עבור כל Circuit | 2048 |
| default_precision | float | הדיוק היעד לערכי ציפייה לאמוד עבור כל Circuit | 0.015625 |
| job_tags | list[str] | רשימת תגיות לעבודה | [] |