ג'ובים של dry-run

ג'וב dry-run מריץ את עומס העבודה שלכם דרך IBM Quantum® Compute Service בלי להשתמש בזמן QPU בכלל. השתמשו בג'וב dry-run כדי לעשות את הדברים הבאים לפני שאתם מתחייבים להרצה אמיתית:

• **לקבל את השימוש שהג'וב היה גורר על ה-QPU האמיתי.

• לאמת את הג'וב. Quantum Compute בודק את הפרמטרים של הג'וב, בדיוק כמו בג'וב אמיתי.

• לקבל את לוח הזמנים של תזמון המעגל, אם תבקשו אותו, כדי לנפות שגיאות בג'וב לפני שמריצים אותו באמת.

בניגוד לג'ובים של dry-run, בדיקה מקומית (fake backends ו-Qiskit Aer) רצה על המחשב שלכם, ולכן לא יכולה לספק נתוני שימוש, אימות בצד השירות או מידע על תזמון מהשירות. להשוואה בין שתי הגישות, ראו התקני mock לעומת fake backends.

הערה

• נדרש qiskit-ibm-runtime בגרסה v0.51.0 ואילך כדי להשתמש בג'ובים של dry-run.
• ג'ובים של dry-run זמינים בכל האזורים, ורק בתוכניות Flex, Premium ו-On-Prem. הם לא זמינים בתוכניות Open או Pay-As-You-Go.

איך זה עובד

כדי להריץ ג'וב dry-run, מעבירים dry_run=True לשיטה run() של ה-primitive:

backend = service.backend("ibm_phoenix")
isa_circuit = pm.run(circuit)  # transpiled for ibm_phoenix
sampler = Sampler(mode=backend)
job = sampler.run([isa_circuit], dry_run=True)
job.result()  # wait for completion
print(job.usage())

dry_run הוא ארגומנט של השיטה run() (ברירת המחדל היא False), ולא אפשרות runtime. הוא זמין לכל ה-primitives.

לג'וב dry-run יש את המאפיינים הבאים:

• הוא רץ ב-IBM Quantum Compute Service בענן, לא על המחשב שלכם.

• הוא משתמש בנתוני הכיול של ה-QPU האמיתי, ולא רק בתמונת מצב.

• התוצאות שלו שומרות על הסכמה הצפויה ועל הצורה הצפויה של תוצאות מה-QPU האמיתי, אבל מכילות נתוני mock אקראיים. אלה אינן תוצאות מדידה אמיתיות או מדומות, ולכן אל תשתמשו בהן כדי לבדוק נכונות פיזיקלית.

• העיבוד מתבצע בשרת, ולכן ייתכן שהג'וב לא יסתיים מיד.

גודל המעגל, מספר ה-shots ומגבלות אחרות זהים לאלה של כל ג'וב של אותה תוכנית.

dry_run=True עובד גם כשה-Backend כבר מהווה התקן mock.

קריאת נתוני השימוש

השימוש של ג'וב dry-run שהסתיים הוא השימוש שאותו ג'וב היה גורר על ה-QPU האמיתי, חוץ ממצבים נדירים שבהם נתוני הכיול משתנים משמעותית אחרי ג'וב ה-dry-run ולפני הג'וב על QPU אמיתי.

• job.usage() מחזיר את השימוש בשניות.

• job.metrics()["usage"] מחזיר את אותם נתונים יחד עם סטטוס השימוש.

השימוש ב-dry-run לא מחויב, לא צורך את מכסת התוכנית שלכם ולא נספר מול אף מגבלה.

אל תשתמשו ב-job.usage_estimation עם ג'ובים של dry-run

אל תשתמשו ב-job.usage_estimation בג'וב dry-run. השתמשו ב-job.usage().

job.usage() מחזיר 0 עד שחישוב השימוש סופי, לכן המתינו לסיום הג'וב לפני שאתם קוראים אותו.

לוח זמנים של תזמון המעגל

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

מגבלות

• רק job mode ו-batch mode. ג'ובים של dry-run יכולים לרוץ רק ב-job mode וב-batch mode.

• רק תוכניות Flex, Premium ו-On-Prem. ג'ובים של dry-run אינם זמינים בתוכניות Open או Pay-As-You-Go.

התקני mock

התקני mock הם המימוש שמאחורי ג'ובים של dry-run. ג'ובים של dry-run מסתירים התקני mock כברירת מחדל, אבל תיתקלו בהם במקרים הבאים:

• מופעים (instances) שמוגדרים לגשת רק להתקני mock. לדוגמה: אם אתם משתמשים ב-service.backend("ibm_phoenix") כדי לשלוח ג'וב dry-run ל-ibm_phoenix, אבל למופע שלכם אין גישה ל-ibm_phoenix, תקבלו QiskitBackendNotFoundError. במקום זה, בחרו את התקן ה-mock ישירות עם service.backend("mock_phoenix").

• משאבי חישוב. התקני mock מוסתרים כברירת מחדל בעמוד Compute resources. בטבלה בעמוד יש אפשרות סינון כדי לכלול אותם, אבל רק לתוכניות Flex, Premium ו-On-Prem יש גישה להתקני mock.

• טבלת Workloads. ג'ובים מהתקני mock מוסתרים כברירת מחדל בעמוד Workloads. בטבלה יש אפשרות סינון (סמל המשפך) כדי להציג אותם.

• Python API. service.backends() ו-service.jobs() לא כוללים התקני mock אלא אם קוראים להם עם include_mocks=True. IBMBackend.is_mock מציין אם Backend הוא התקן mock. service.least_busy() אף פעם לא מחזיר התקן mock.

התקני mock לעומת fake backends

השמות דומים, אבל התקן mock ו-fake backend הם דברים שונים. fake backend הוא אובייקט מקומי בסביבת ה-Python שלכם. התקן mock הוא משאב ענן ב-IBM Quantum Compute Service.

	התקן mock (לדוגמה mock_phoenix)	fake backend (לדוגמה FakeManilaV2)
מה זה	התקן ב-IBM Quantum Compute Service	מחלקת Python ב-qiskit_ibm_runtime.fake_provider
איפה רץ	בענן, בשירות	מקומית, על המחשב שלכם
איך מקבלים	service.backend("mock_phoenix"), או אוטומטית עם run(..., dry_run=True)	from qiskit_ibm_runtime.fake_provider import ...
חשבון ומופע	תוכניות מסוימות בלבד (Flex, Premium או On-Prem)	כל המופעים והתוכניות
כיול	חי, תואם להתקן האמיתי בכל רגע	תמונת מצב קבועה שמגיעה עם החבילה המותקנת
תוצאות	נתונים אקראיים עם הסכמה הצפויה. לא סימולציה	סימולציה רועשת שמשתמשת במודל הרעש של תמונת המצב
תוצאות בעלות משמעות פיזיקלית	לא. לעולם אל תשתמשו בהן כדי לבדוק נכונות	בקירוב, בגבולות מודל הרעש
דיווח שימוש	כן	אין
מחויב או נספר מול מכסת התוכנית או מגבלות	לא	לא
אימות ג'וב	מתבצע בשירות, כמו בג'וב אמיתי	מוגבל למה שהלקוח בודק
לוח זמנים של תזמון	זמין לפי בקשה	לא זמין
מצבי הרצה	רק job mode ו-batch mode. Sessions חסומים	תחביר Session מתקבל אך מתעלמים ממנו (במצב מקומי אין Sessions או batches אמיתיים)
סיום	אסינכרוני, בשרת	רץ מקומית וחוזר כשהוא מסתיים
מוצג בממשק הפלטפורמה וברשימות ה-API	מוסתר כברירת מחדל (Compute resources, טבלת Workloads, backends(), jobs()). אפשר להפעיל הצגה	אף פעם, כי שום דבר לא נשלח לשירות

איך לבחור

• כדי לגלות כמה שימוש הג'וב יצרוך, או אם השירות יקבל אותו, השתמשו בג'וב dry-run.

• כדי לגלות איך הפלט עשוי להיראות, או כדי לעבוד במצב לא מקוון, השתמשו ב-fake backend או ב-Aer.

• כדי לעשות את שניהם, חזרו על מעגלים ותוצאות עם fake backend, ואז הריצו dry-run כבדיקה אחרונה לפני ה-QPU האמיתי.

נקודות בלבול נפוצות

• התקן mock הוא לא סימולטור. הפלט שלו אקראי, ולכן דגימה של מעגל Bell על mock_phoenix לא מחזירה התפלגות Bell. אם אתם רוצים פלט רועש ריאליסטי, השתמשו ב-fake backend.

• fake backend הוא לא ההתקן החי. הכיול שלו הוא תמונת מצב ועלול להיות לא מעודכן. התקן mock עוקב אחרי הכיול האמיתי, ולכן מעגלים שעברו transpile ותזמון תואמים למה שה-QPU רואה היום.

• אף אחד מהם לא רץ על חומרה אמיתית. אף אחד מהם לא צורך זמן QPU, אבל רק ג'וב dry-run עובר דרך השירות.

• usage_estimation הוא לא האומדן של dry-run. עבור ג'וב dry-run, job.usage() מחזיר את שניות השימוש שהג'וב שלכם היה מחויב בהן על QPU אמיתי.

מקרי שימוש

סטודנטים וקורסים

מנהל מערכת מגביל מופע להתקני mock בלבד, באמצעות מתג התאמת ה-QPU כש-יוצרים או עורכים את המופע. אז סטודנטים יכולים לאמת את ה-payloads שלהם מקצה לקצה בלי לצרוך זמן QPU אמיתי או RUs. מכיוון שלמופע יש גישה רק להתקני mock, סטודנטים בוחרים את ה-Backend לפי שם ה-mock שלו:

backend = service.backend("mock_phoenix")
sampler = Sampler(mode=backend)
job = sampler.run([isa_circuit], dry_run=True)

תכנון פרויקט

צוות שעומד להתחיל פרויקט מריץ dry-run על ג'ובים מייצגים כדי לראות כמה RUs הפרויקט צריך, לפני שבוחרים תוכנית או מכסה:

backend = service.backend("ibm_phoenix")
sampler = Sampler(mode=backend)
job = sampler.run([isa_circuit], dry_run=True)
job.result()
print(job.usage()) 

בדיקה אחרונה לפני הרצה על QPU אמיתי

אמתו פרמטרים ובדקו את לוח הזמנים של התזמון עם dry_run=True, ואז הסירו את הארגומנט והריצו על ה-QPU האמיתי. שום דבר אחר בקוד שלכם לא משתנה:

sampler = Sampler(mode=backend)

# Pre-flight check
job = sampler.run([isa_circuit], dry_run=True)
job.result()

# Real run - same code, without dry_run
job = sampler.run([isa_circuit])

השלבים הבאים

המלצות

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