Einen Job überwachen oder abbrechen

Dieser Leitfaden erklärt, wie du den Job-Status überwachst, Nutzungsinformationen einsiehst und Jobs abbrichst. Du kannst auf diese Informationen sowohl über die IBM Quantum® Platform als auch programmatisch mit Qiskit zugreifen.

Paketversionen

Der Code auf dieser Seite wurde mit den folgenden Anforderungen entwickelt. Wir empfehlen, diese Versionen oder neuere zu verwenden.

qiskit-ibm-runtime~=0.46.1

Einen Job überwachen

Verwende diese Methoden, um den Status deiner eingereichten Jobs zu überprüfen, Ergebnisse abzurufen und Details zum Job und dessen Ausführung anzuzeigen.

Einen Job mit Qiskit überwachen
Einen Job auf der IBM Quantum Platform überwachen

Die Job-Instanz bietet mehrere Methoden zur Überwachung:

Methode	Beschreibung
`job.status()`	Den aktuellen Job-Status überprüfen
`job.job_id()`	Die eindeutige Job-Kennung abrufen
`job.result()`	Job-Ergebnisse abrufen (blockierender Aufruf bis zum Abschluss)
`job.wait_for_final_state()`	Blockieren, bis der Job einen Endzustand erreicht

Warum ein Job „In progress” bleibt

Möglicherweise bemerkst du, dass ein Job (im job mode oder im batch mode), von dem du erwartest, dass er nur wenige Sekunden dauert, viel länger im Status In progress (in Qiskit RUNNING genannt) verbleibt. Das ist normal und bedeutet nicht, dass der Job diese gesamte Zeit als Nutzung verbraucht. Dies geschieht aufgrund der Art und Weise, wie Jobs auf einer QPU eingeplant werden:

Jeder Job erfordert eine klassische Vorverarbeitung, bevor er auf der QPU ausgeführt werden kann. Ein Job wechselt in den Status In progress (RUNNING), sobald diese klassische Verarbeitung beginnt — nicht wenn die Ausführung auf der QPU startet.
Der Großteil dieser klassischen Verarbeitung läuft parallel, sodass mehrere Jobs gleichzeitig In progress sein können.
Allerdings kann jeweils nur ein Job auf der QPU ausgeführt werden. Wenn mehrere Jobs ihre klassische Verarbeitung abgeschlossen haben und ausführungsbereit sind, müssen sie auf die QPU warten. Dies wird als QPU-Contention bezeichnet. Bei hoher Contention kann ein Job merklich länger In progress bleiben als die wenigen Sekunden QPU-Zeit, die er tatsächlich benötigt.
Contention kann auch auftreten, wenn eine Systemwartungsaufgabe, wie z. B. eine Kalibrierung, auf der QPU läuft. Dein Job bleibt In progress, bis die Wartungsaufgabe abgeschlossen ist und die QPU wieder verfügbar wird.

Aus diesem Grund entspricht die verstrichene Echtzeit, die ein Job im Status In progress verbringt, nicht seiner Nutzung. Sowohl die geschätzte Nutzung als auch die maximale Ausführungszeit basieren nur auf der Zeit, in der die QPU für die Ausführung deines Jobs reserviert ist, und schließen daher die oben beschriebene, parallel laufende klassische Verarbeitung aus. Eine lange In progress-Zeit erhöht deine gemeldete Nutzung oder Kosten nicht.

Session mode ist anders

Das vorstehende Verhalten gilt für den job mode und den batch mode. Im session mode hat der Nutzer während des aktiven Zeitfensters der Session exklusiven Zugriff auf das Backend, und es können keine anderen Jobs laufen, einschließlich Kalibrierungsjobs. Daher tritt jegliche QPU-Contention nur zwischen deinen eigenen Session-Jobs auf. Da die QPU-Kapazität für die Dauer der Session reserviert ist, wird die Session-Nutzung außerdem als die verstrichene Zeit gemessen, während der die Session aktiv bleibt, unabhängig davon, ob gerade Jobs ausgeführt werden. Weitere Informationen findest du unter Workload-Nutzung.

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

Verbleibendes Kontingent anzeigen

Verfolge, wie viel von deinem Nutzungskontingent noch übrig ist.

Nutzung mit Qiskit überprüfen
Nutzung auf der IBM Quantum Platform anzeigen

Verwende die Methode service.usage(), um Nutzungsinformationen für deine aktuell aktive Instanz abzurufen.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

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

Job-Metriken anzeigen

Erhalte einen Überblick über deine Job-Einreichungen, einschließlich Batch- und Session-Workload-Metriken.

Job-Metriken mit Qiskit abrufen
Job-Metriken auf der IBM Quantum Platform anzeigen

Verwende die Methode service.jobs() mit Filtern, um Informationen über deine eingereichten Jobs abzurufen, z. B. wie viele eingereicht wurden, welchen Status sie haben und wann sie erstellt wurden. Das folgende Beispiel ruft alle in den letzten sieben Tagen eingereichten Jobs ab und berechnet die Gesamtnutzung aus diesen 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")

Job-Ergebnisse zu einem späteren Zeitpunkt abrufen

Du kannst Job-IDs speichern und Ergebnisse später abrufen, auch nachdem du deine Sitzung geschlossen hast.

Ergebnisse mit Qiskit abrufen
Ergebnisse auf der IBM Quantum Platform abrufen

Wenn du die Job-ID beim Einreichen des Jobs gespeichert hast, verwende service.job(<job_id>), um sie später abzurufen. Wenn du die Job-ID nicht hast oder mehrere Jobs auf einmal abrufen möchtest (einschließlich Jobs von ausgemusterten QPUs), verwende stattdessen service.jobs() mit optionalen Filtern.

Die verfügbaren Filter findest du in der API-Dokumentation zu QiskitRuntimeService.jobs.

Dieses Beispiel zeigt das Abrufen aktueller Ergebnisse, die auf einem bestimmten Backend ausgeführt wurden.

Backend-Eigenschaften abrufen

Backend-Eigenschaften mit Qiskit abrufen
Backend-Eigenschaften auf der IBM Quantum Platform abrufen

Du kannst job.properties() verwenden, um Backend-Eigenschaften, einschließlich Fehlerraten, zum Zeitpunkt der Job-Ausführung abzurufen.

Dieses Beispiel zeigt, wie du Backend-Eigenschaften abrufst, die zum Zeitpunkt der Job-Ausführung aktuell waren, einschließlich $T_1$ / $T_2$ -Zeiten und Fehlerraten für ein bestimmtes Qubit (0).

Veraltete Provider-Pakete

service.jobs() gibt auch Jobs zurück, die mit dem veralteten qiskit-ibm-provider-Paket ausgeführt wurden. Jobs, die mit dem älteren (ebenfalls veralteten) qiskit-ibmq-provider-Paket eingereicht wurden, sind nicht mehr verfügbar.

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

Einen Job abbrechen

Breche einen Job ab, der in der Warteschlange steht oder ausgeführt wird. Sobald ein Job abgebrochen wurde, kann er nicht fortgesetzt werden.

Mit Qiskit abbrechen
Auf der IBM Quantum Platform abbrechen

Verwende die Methode job.cancel(), um einen Job programmatisch abzubrechen.

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

Nächste Schritte

Empfehlungen

Sieh dir die QiskitRuntimeService-API-Referenz für weitere Methoden zur Job-Verwaltung an.
Erkunde die Ausführungsmodi, um Batch- und Session-Workload-Typen zu verstehen.

Einen Job überwachen​

Warum ein Job „In progress” bleibt​

Session mode ist anders​

Verbleibendes Kontingent anzeigen​

Job-Metriken anzeigen​

Job-Ergebnisse zu einem späteren Zeitpunkt abrufen​

Backend-Eigenschaften abrufen​

Einen Job abbrechen​

Nächste Schritte​