דלג לתוכן הראשי
פרויקט זה בשלב בטא. מצאת באג? פתח issue ב-GitHub. יש שאלה או רעיון? שאל ב-Discussions — נשמח לשמוע ממך!
מה איכות התרגום בדף זה?

ניטור או ביטול עבודה

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

גרסאות חבילה

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

qiskit-ibm-runtime~=0.46.1

ניטור עבודה​

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

מופע העבודה מספק כמה שיטות למעקב:

MethodDescription
job.status()בדוק את הסטטוס הנוכחי של העבודה
job.job_id()קבל את מזהה העבודה הייחודי
job.result()אחזר את תוצאות העבודה (קריאה חוסמת עד להשלמה)
job.wait_for_final_state()חסום עד שהעבודה מגיעה למצב סופי

מדוע עבודה נשארת "בתהליך"​

ייתכן שתשים לב שעבודה (בין אם ב-job mode או ב-batch mode) שאתה מצפה שתיקח רק כמה שניות נשארת בסטטוס בתהליך (הנקרא RUNNING ב-Qiskit) הרבה יותר זמן. זה נורמלי, וזה לא אומר שהעבודה צורכת את כל אותו הזמן כשימוש. זה קורה בגלל האופן שבו עבודות מתוזמנות על QPU:

  • כל עבודה דורשת עיבוד מקדים קלאסי לפני שהיא יכולה לפעול על ה-QPU. עבודה עוברת ל-בתהליך (RUNNING) ברגע שהעיבוד הקלאסי הזה מתחיל — לא כאשר היא מתחילה לפעול על ה-QPU.

  • רוב העיבוד הקלאסי הזה פועל במקביל, כך שעבודות מרובות יכולות להיות בתהליך באותו הזמן.

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

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

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

Session mode שונה​

ההתנהגות הקודמת חלה על job mode ו-batch mode. ב-session mode, במהלך חלון הפעילות של הסשן, למשתמש יש גישה בלעדית ל-Backend ואף עבודה אחרת לא יכולה לפעול, כולל עבודות כיול. לכן, כל תחרות QPU מתרחשת רק בין עבודות הסשן שלך עצמך. בנוסף, מכיוון שקיבולת ה-QPU שמורה למשך הסשן, שימוש הסשן נמדד כזמן שחלף בזמן שהסשן נשאר פעיל, בין אם עבודות פועלות בפועל ובין אם לא. ראה שימוש בעומס עבודה למידע נוסף.

# 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")
from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

# Retrieve a job by ID
job = service.job("<job_id>")

# Get job ID (useful for saving for later retrieval)
print(f"Job ID: {job.job_id()}")

# Check current status
print(f"Status: {job.status()}")

# Wait for job to complete (blocking call)
job.wait_for_final_state()
print("Job completed")

# Get results
results = job.result()
print(results)

צפייה בשימוש הנותר​

עקוב אחר כמה ממכסת השימוש בתוכנית שלך נותרה.

השתמש בשיטה service.usage() כדי לקבל מידע שימוש עבור המופע הפעיל הנוכחי שלך.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

# Get usage information for the current active instance
usage = service.usage()
print(usage)

צפייה במדדי עבודה​

קבל סקירה כללית של הגשות העבודה שלך, כולל מדדי עומסי עבודה של batch ו-session.

השתמש בשיטה service.jobs() עם מסננים כדי לאחזר מידע על העבודות שהגשת, כגון כמה הוגשו, מה הסטטוסים שלהן, ומתי נוצרו. הדוגמה הבאה מאחזרת את כל העבודות שהוגשו בשבעת הימים האחרונים ומחשבת את השימוש הכולל מעבודות אלה.

from datetime import datetime, timedelta
from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

# Retrieve all jobs in the last 7 days
seven_days_ago = datetime.now() - timedelta(days=7)
jobs = service.jobs(limit=None, created_after=seven_days_ago)

# To retrieve all jobs in a Session or Batch, use the session_id filter
# jobs = service.jobs(session_id="<session id>")

total_usage = 0
for job in jobs:
    total_usage += job.usage()

print(f"{len(jobs)} jobs were submitted in the last 7 days.")
print(f"Total usage was {total_usage} seconds")

אחזור תוצאות עבודה בשלב מאוחר יותר​

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

אם שמרת את מזהה העבודה כאשר הגשת את העבודה, השתמש ב-service.job(<job_id>) כדי לאחזר אותה מאוחר יותר. אם אין לך את מזהה העבודה, או אם ברצונך לאחזר מספר עבודות בבת אחת (כולל עבודות מ-QPU שיצאו משימוש), השתמש ב-service.jobs() במקום זאת, עם מסננים אופציונליים.

ראה את תיעוד ה-API של QiskitRuntimeService.jobs עבור מסננים זמינים.

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

אחזור תכונות Backend​

תוכל להשתמש ב-job.properties() כדי לאחזר תכונות Backend, כולל שיעורי שגיאה, בזמן ביצוע העבודה.

דוגמה זו מדגימה כיצד לאחזר תכונות Backend שהיו בתוקף בזמן שעבודה בוצעה, כולל זמני T1T_1/T2T_2 ושיעורי שגיאה עבור קיוביט ספציפי (0).

חבילות ספק מיושנות

service.jobs() גם מחזיר עבודות שהורצו מחבילת qiskit-ibm-provider המיושנת. עבודות שהוגשו על ידי חבילת qiskit-ibmq-provider הישנה (גם היא מיושנת) אינן זמינות עוד.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

# Uncomment the next line to retrieve a specific job by ID
# job = service.job("<job_id>")

# Optionally retrieve multiple jobs with filters
# Use `limit` to retrieve a specific number of jobs. The default `limit` is 10.
my_backend = "<your-backend>"
recent_jobs = service.jobs(backend_name=my_backend, limit=10)

print(f"Retrieved {len(recent_jobs)} recent jobs from {my_backend}\n")

# Get results from all jobs
for job in recent_jobs:
    print(f"Job ID: {job.job_id()}")
    print(f"Status: {job.status()}")

    # Retrieve results if the job is complete
    if str(job.status()) == "DONE":
        try:
            results = job.result()
            print(f"Results: {results}")
        except Exception as e:
            print(f"Error retrieving results: {e}")
    else:
        print("Results: Not available (job still running or failed)")
    print()
from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

# Retrieve a specific job by ID
job = service.job("<job_id>")

print(f"Job ID: {job.job_id()}")
print(f"Backend: {job.backend}\n")

# Fetch backend properties at the time of job execution
properties = job.properties()

if properties:
    print("Backend Properties at Job Execution Time:")
    print("=" * 60)

    # Get T1 (relaxation time) for qubit 0
    t1 = properties.t1(0)
    print(f"Qubit 0 T1 (relaxation time): {t1}")

    # Get T2 (dephasing time) for qubit 0
    t2 = properties.t2(0)
    print(f"Qubit 0 T2 (dephasing time): {t2}")

    # Get readout error for qubit 0
    readout_error = properties.readout_error(0)
    print(f"Qubit 0 readout error: {readout_error}")

    # Get all properties for a specific qubit
    print("All properties for qubit 0:")
    qubit_props = properties.qubit_property(0)
    for prop_name, prop_value in qubit_props.items():
        print(f"  {prop_name}: {prop_value}")
else:
    print("No properties available for this job")

ביטול עבודה​

בטל עבודה שנמצאת בתור או פועלת. ברגע שעבודה מבוטלת, לא ניתן להמשיך אותה.

השתמש בשיטה job.cancel() כדי לבטל עבודה באופן תכנותי.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

# Retrieve the job
job = service.job("<job_id>")

# Cancel the job
job.cancel()

print(f"Job {job.job_id()} has been canceled")

השלבים הבאים​

המלצות
מקור: תיעוד IBM Quantum — עודכן בתאריך 13 באוג׳ 2026
גרסה באנגלית ב-doQumentation — עודכן בתאריך 13 באוג׳ 2026
בעיה באתר או בתרגום?בעיה בתוכן? ערוך ב-IBM Quantum docs