Auftrag überwachen oder abbrechen

In dieser Anleitung wird erläutert, wie Sie den Status von Aufträgen überwachen, Nutzungsinformationen einsehen und Aufträge abbrechen können. Sie können auf diese Informationen sowohl über IBM Quantum® Platform als auch programmgesteuert mithilfe von Qiskit zugreifen.

• Paketversionen

  Der Code auf dieser Seite wurde unter Berücksichtigung der folgenden Anforderungen entwickelt. Wir empfehlen, diese Versionen oder neuere zu verwenden.

  qiskit-ibm-runtime~=0.46.1
  

Einen Auftrag überwachen

Mit diesen Methoden können Sie den Status Ihrer übermittelten Aufträge überprüfen, Ergebnisse abrufen und Details zum Auftrag und dessen Ausführung einsehen.

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)

Warum ein Auftrag den Status „In Bearbeitung“ behält

Möglicherweise stellen Sie fest, dass ein Job (entweder im Job-Modus oder im Batch-Modus), von dem Sie erwarten, dass er nur wenige Sekunden dauert, viel länger im Status „In Bearbeitung “ (in RUNNING Qiskit als bezeichnet) verbleibt. Das ist normal und bedeutet nicht, dass der Job die gesamte Zeit in Anspruch nimmt. Das liegt daran, wie Jobs auf einer QPU eingeplant werden:

• Jeder Auftrag erfordert eine klassische Vorverarbeitung, bevor er auf der QPU ausgeführt werden kann. Ein Auftrag wechselt in den Status „In Bearbeitung (RUNNING)“, sobald diese klassische Verarbeitung beginnt – nicht erst, wenn die Ausführung auf der QPU startet.
• Der Großteil dieser klassischen Verarbeitung läuft parallel ab, sodass mehrere Aufträge gleichzeitig in Bearbeitung sein können.
• Auf der QPU kann jedoch jeweils nur ein Job ausgeführt werden. Wenn mehrere Jobs ihre klassische Verarbeitung abgeschlossen haben und zur Ausführung bereit sind, müssen sie warten, bis sie an der Reihe sind, die QPU zu nutzen. Dies wird als QPU-Konflikt bezeichnet. Bei hoher Auslastung kann ein Job deutlich länger im Status „In Bearbeitung“ verbleiben als die wenigen Sekunden an QPU-Zeit, die er tatsächlich benötigt.
• Zu Konflikten kann es auch kommen, wenn auf der QPU eine Systemwartungsaufgabe, wie beispielsweise eine Kalibrierung, ausgeführt wird. Ihr Auftrag bleibt im Status „In Bearbeitung“, bis die Wartungsaufgabe abgeschlossen ist und die QPU wieder verfügbar ist.

Aus diesem Grund entspricht die tatsächlich verstrichene Zeit, die ein Auftrag im Status „In Bearbeitung“ verbringt, nicht seiner Auslastung. Sowohl die geschätzte Nutzungsdauer als auch die maximale Ausführungszeit basieren ausschließlich auf der Zeit, in der die QPU für die Ausführung Ihres Auftrags reserviert ist, und berücksichtigen daher nicht die oben beschriebene klassische Multithread-Verarbeitung. Eine lange Bearbeitungsdauer führt nicht zu einer Erhöhung Ihrer ausgewiesenen Nutzung oder Ihrer Kosten.

Der Sitzungsmodus ist anders

Das oben beschriebene Verhalten gilt sowohl für den Job-Modus als auch für den Batch-Modus. Im Sitzungsmodus hat der Benutzer während der aktiven Sitzungsdauer exklusiven Zugriff auf das Backend, und es können keine anderen Aufträge ausgeführt werden, einschließlich Kalibrierungsaufträge. Daher treten etwaige QPU-Konflikte ausschließlich zwischen den Jobs Ihrer eigenen Sitzung auf. Da die QPU-Kapazität zudem für die Dauer der Sitzung reserviert ist, wird die Sitzungsnutzung als die verstrichene Zeit gemessen, während die Sitzung aktiv ist – unabhängig davon, ob Jobs gerade aktiv ausgeführt werden. Weitere Informationen finden Sie unter „Workload-Nutzung “.

Verbleibende Nutzung anzeigen

Verfolgen Sie nach, wie viel von Ihrem Nutzungskontingent noch übrig ist.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

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

Stellenkennzahlen anzeigen

Verschaffen Sie sich einen Überblick über Ihre Job-Einreichungen, einschließlich der Kennzahlen zur Auslastung von Batches und Sitzungen.

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

Sie können Job-IDs speichern und die Ergebnisse später abrufen, auch nachdem Sie Ihre Sitzung beendet haben.

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

Backend-Eigenschaften abrufen

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 abbrechen

Einen Auftrag abbrechen, der in der Warteschlange steht oder gerade ausgeführt wird. Sobald ein Auftrag abgebrochen wurde, kann er nicht mehr fortgesetzt werden.

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