{ "cells": [ { "cell_type": "markdown", "id": "810fe365-8557-46b0-97e7-324b08a1c6e2", "metadata": {}, "source": [ "---\n", "title: \"Auftrag überwachen oder abbrechen\"\n", "description: \"So überwachen oder stornieren Sie einen an IBM Quantum Platform übermittelten Auftrag\"\n", "---\n", "\n", "\n", "\n", "# Auftrag überwachen oder abbrechen\n", "\n", "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.\n", "\n" ] }, { "cell_type": "markdown", "id": "866ed6ab-a597-402e-876a-8315ac5ed9e6", "metadata": { "tags": [ "version-info" ] }, "source": [ "\n" ] }, { "cell_type": "markdown", "id": "bb84ab8e-6db9-45d6-bb59-2f06f38d9965", "metadata": {}, "source": [ "{/*\n", " DO NOT EDIT THIS CELL!!!\n", " This cell's content is generated automatically by a script. Anything you add\n", " here will be removed next time the notebook is run. To add new content, create\n", " a new cell before or after this one.\n", " */}\n", "\n", "\n", " \n", " Der Code auf dieser Seite wurde unter Berücksichtigung der folgenden Anforderungen entwickelt.\n", " Wir empfehlen, diese Versionen oder neuere zu verwenden.\n", "\n", " ```\n", " qiskit-ibm-runtime~=0.46.1\n", " ```\n", " \n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "view-status", "metadata": {}, "source": [ "\n", "\n", "## Einen Auftrag überwachen\n", "\n", "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.\n", "\n", "\n", " \n", " Die Job-Instanz bietet verschiedene Methoden zur Überwachung:\n", "\n", " | Methode | Beschreibung |\n", " | ---------------------------- | ------------------------------------------------------------------- |\n", " | `job.status()` | Aktuellen Auftragsstatus prüfen |\n", " | `job.job_id()` | Die eindeutige Auftrags-ID abrufen |\n", " | `job.result()` | Auftragsergebnisse abrufen (blockierender Aufruf bis zum Abschluss) |\n", " | `job.wait_for_final_state()` | Blockieren, bis der Auftrag einen Endzustand erreicht hat |\n", "\n", " \n", " \n", "\n", " \n", " Wechseln Sie zur [Seite](/workloads) „Workloads“ und sehen Sie in der Spalte „Status“ nach. Ihr Beschäftigungsstatus wird wie folgt angezeigt:\n", "\n", " * **Ausstehend** : Der Job wartet darauf, auf einer QPU ausgeführt zu werden\n", " * **Wird ausgeführt** : Der Auftrag wird derzeit ausgeführt\n", " * **Abgeschlossen** : Auftrag erfolgreich abgeschlossen\n", " * **Fehlgeschlagen** : Bei dem Auftrag ist ein Fehler aufgetreten\n", " * **Abgebrochen** : Der Benutzer hat den Auftrag abgebrochen\n", "\n", " Klicken Sie auf den Namen des Auftrags oder auf die entsprechende Zeile, um die Detailansicht zu öffnen, in der Sie Informationen wie die Ergebnisse und etwaige Fehlermeldungen einsehen können.\n", " \n", "\n", "\n", "\n", "\n", "### Warum ein Auftrag den Status „In Bearbeitung“ behält\n", "\n", "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:\n", "\n", "* 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.\n", "* Der Großteil dieser klassischen Verarbeitung läuft parallel ab, sodass mehrere Aufträge gleichzeitig **in Bearbeitung** sein können.\n", "* 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.\n", "* 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.\n", "\n", "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](/docs/guides/estimate-job-run-time) als auch die [maximale Ausführungszeit](/docs/guides/max-execution-time) 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.\n", "\n", "\n", "\n", "#### Der Sitzungsmodus ist anders\n", "\n", "Das oben beschriebene Verhalten gilt sowohl für [den Job-Modus](/docs/guides/execution-modes#job-mode) als auch für [den Batch-Modus](/docs/guides/execution-modes#batch-mode). Im [Sitzungsmodus](/docs/guides/execution-modes#session-mode) 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](/docs/guides/estimate-job-run-time#usage) “.\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "ee0318b6-0bfd-4f0b-b980-4e233a2d5d7b", "metadata": { "tags": [ "id-status" ] }, "outputs": [], "source": [ "from qiskit_ibm_runtime import QiskitRuntimeService\n", "\n", "service = QiskitRuntimeService()\n", "\n", "# Retrieve a job by ID\n", "job = service.job(\"\")\n", "\n", "# Get job ID (useful for saving for later retrieval)\n", "print(f\"Job ID: {job.job_id()}\")\n", "\n", "# Check current status\n", "print(f\"Status: {job.status()}\")\n", "\n", "# Wait for job to complete (blocking call)\n", "job.wait_for_final_state()\n", "print(\"Job completed\")\n", "\n", "# Get results\n", "results = job.result()\n", "print(results)" ] }, { "cell_type": "markdown", "id": "view-usage", "metadata": {}, "source": [ "\n", "\n", "## Verbleibende Nutzung anzeigen\n", "\n", "Verfolgen Sie nach, wie viel von Ihrem Nutzungskontingent noch übrig ist.\n", "\n", "\n", " \n", " Verwenden Sie die Methode `service.usage()` , um Nutzungsinformationen für Ihre derzeit aktive Instanz abzurufen.\n", "\n", " \n", " \n", "\n", " \n", " Rufen Sie die [Seite „Instanzen“](/instances) auf und wählen Sie die Registerkarte aus, die dem Tarif zugeordnet ist, den Sie überprüfen möchten. Die insgesamt verbrauchte Zeit und die verbleibende Gesamtzeit Ihres Tarifs werden angezeigt.\n", " \n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "usage-code", "metadata": { "tags": [ "id-usage" ] }, "outputs": [], "source": [ "from qiskit_ibm_runtime import QiskitRuntimeService\n", "\n", "service = QiskitRuntimeService()\n", "\n", "# Get usage information for the current active instance\n", "usage = service.usage()\n", "print(usage)" ] }, { "cell_type": "markdown", "id": "view-metrics", "metadata": {}, "source": [ "\n", "\n", "## Stellenkennzahlen anzeigen\n", "\n", "Verschaffen Sie sich einen Überblick über Ihre Job-Einreichungen, einschließlich der Kennzahlen zur Auslastung von Batches und Sitzungen.\n", "\n", "\n", " \n", " Verwenden Sie die Methode [`service.jobs()`](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#jobs) mit Filtern, um Informationen zu Ihren übermittelten Aufträgen abzurufen, z. B. wie viele Aufträge übermittelt wurden, welchen Status sie haben und wann sie erstellt wurden. Das folgende Beispiel ruft alle in den letzten sieben Tagen übermittelten Jobs ab und berechnet die Gesamtauslastung dieser Jobs.\n", "\n", " \n", " \n", "\n", " \n", " Rufen Sie die [Seite „Analytics“](/analytics) auf, um Daten wie die folgenden anzuzeigen und herunterzuladen:\n", "\n", " * Gesamtnutzung\n", " * Nutzung, gefiltert nach Instanz, Quantencomputer und Benutzer\n", " * Zählung der Arbeitslasten nach Jobs, Batches und Sitzungen\n", "\n", " **Hinweis** : Sie können nur auf die Analytics-Seite für Konten zugreifen, deren Inhaber Sie sind oder die Sie verwalten.\n", " \n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "metrics-code", "metadata": { "tags": [ "id-metrics" ] }, "outputs": [], "source": [ "from datetime import datetime, timedelta\n", "from qiskit_ibm_runtime import QiskitRuntimeService\n", "\n", "service = QiskitRuntimeService()\n", "\n", "# Retrieve all jobs in the last 7 days\n", "seven_days_ago = datetime.now() - timedelta(days=7)\n", "jobs = service.jobs(limit=None, created_after=seven_days_ago)\n", "\n", "# To retrieve all jobs in a Session or Batch, use the session_id filter\n", "# jobs = service.jobs(session_id=\"\")\n", "\n", "total_usage = 0\n", "for job in jobs:\n", " total_usage += job.usage()\n", "\n", "print(f\"{len(jobs)} jobs were submitted in the last 7 days.\")\n", "print(f\"Total usage was {total_usage} seconds\")" ] }, { "cell_type": "markdown", "id": "retrieve-later", "metadata": {}, "source": [ "\n", "\n", "## Job-Ergebnisse zu einem späteren Zeitpunkt abrufen\n", "\n", "Sie können Job-IDs speichern und die Ergebnisse später abrufen, auch nachdem Sie Ihre Sitzung beendet haben.\n", "\n", "\n", " \n", " Wenn Sie die Auftrags-ID beim Absenden des Auftrags gespeichert haben, `service.job()` können Sie sie später über abrufen. Wenn Sie die Job-ID nicht haben oder mehrere Jobs gleichzeitig abrufen möchten (einschließlich Jobs von stillgelegten QPUs), verwenden Sie stattdessen `service.jobs()` mit optionalen Filtern.\n", "\n", " Informationen zu den verfügbaren Filtern finden Sie in der [`QiskitRuntimeService.jobs`](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#jobs) API-Dokumentation.\n", "\n", " Dieses Beispiel veranschaulicht, wie man die zuletzt auf einem bestimmten Backend ausgeführten Ergebnisse abruft.\n", "\n", " \n", " \n", "\n", " \n", " 1. Rufen Sie die [Seite „Workloads“](/workloads) auf.\n", " 2. Nutzen Sie die Such- oder Filteroptionen, um Ihren Auftrag nach Name, Datum oder Status zu finden.\n", " 3. Klicken Sie auf den Auftrag, um dessen Ergebnisse und Details anzuzeigen.\n", " \n", "\n", "\n", "\n", "\n", "## Backend-Eigenschaften abrufen\n", "\n", "\n", " \n", " Mit können Sie Backend-Eigenschaften, einschließlich Fehlerquoten, zum Zeitpunkt der Auftragsausführung `job.properties()` abrufen.\n", "\n", " Dieses Beispiel veranschaulicht, wie man Backend-Eigenschaften abruft, die zum Zeitpunkt der Ausführung eines Jobs aktuell waren, darunter die Zeiten für „ $T_1$ “ und „ $T_2$ “ sowie die Fehlerraten für ein bestimmtes Qubit (0).\n", "\n", " \n", "\n", " \n", " `service.jobs()` gibt auch Aufträge zurück, die mit dem veralteten Paket `qiskit-ibm-provider` ausgeführt wurden. Aufträge, die mit dem älteren (ebenfalls veralteten) Paket `qiskit-ibmq-provider` eingereicht wurden, sind nicht mehr verfügbar.\n", " \n", " \n", "\n", " \n", " Sie können die Kalibrierungsdaten für das Backend sowohl zum Zeitpunkt der Auftragsausführung als auch bei der Auftragserstellung einsehen.\n", "\n", " 1. Zur [Seite](/workloads) „Workloads“ wechseln\n", " 2. Klicken Sie auf eine Arbeitslast, um deren Detailseite zu öffnen\n", " 3. Klicken Sie unter „Quantencomputer“ auf „Kalibrierungsverlauf anzeigen“\n", " 4. Verwenden Sie das Dropdown-Menü, um die Anzeige der Daten von „Zu Beginn der Jobausführung“ auf „Bei der Joberstellung“ umzustellen\n", " \n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "retrieve-code", "metadata": { "tags": [ "id-retrieve" ] }, "outputs": [], "source": [ "from qiskit_ibm_runtime import QiskitRuntimeService\n", "\n", "service = QiskitRuntimeService()\n", "\n", "# Uncomment the next line to retrieve a specific job by ID\n", "# job = service.job(\"\")\n", "\n", "# Optionally retrieve multiple jobs with filters\n", "# Use `limit` to retrieve a specific number of jobs. The default `limit` is 10.\n", "my_backend = \"\"\n", "recent_jobs = service.jobs(backend_name=my_backend, limit=10)\n", "\n", "print(f\"Retrieved {len(recent_jobs)} recent jobs from {my_backend}\\n\")\n", "\n", "# Get results from all jobs\n", "for job in recent_jobs:\n", " print(f\"Job ID: {job.job_id()}\")\n", " print(f\"Status: {job.status()}\")\n", "\n", " # Retrieve results if the job is complete\n", " if str(job.status()) == \"DONE\":\n", " try:\n", " results = job.result()\n", " print(f\"Results: {results}\")\n", " except Exception as e:\n", " print(f\"Error retrieving results: {e}\")\n", " else:\n", " print(\"Results: Not available (job still running or failed)\")\n", " print()" ] }, { "cell_type": "code", "execution_count": null, "id": "55afa300-0af7-4f5e-8b32-c32b6ba39621", "metadata": { "tags": [ "id-backend-properties" ] }, "outputs": [], "source": [ "from qiskit_ibm_runtime import QiskitRuntimeService\n", "\n", "service = QiskitRuntimeService()\n", "\n", "# Retrieve a specific job by ID\n", "job = service.job(\"\")\n", "\n", "print(f\"Job ID: {job.job_id()}\")\n", "print(f\"Backend: {job.backend}\\n\")\n", "\n", "# Fetch backend properties at the time of job execution\n", "properties = job.properties()\n", "\n", "if properties:\n", " print(\"Backend Properties at Job Execution Time:\")\n", " print(\"=\" * 60)\n", "\n", " # Get T1 (relaxation time) for qubit 0\n", " t1 = properties.t1(0)\n", " print(f\"Qubit 0 T1 (relaxation time): {t1}\")\n", "\n", " # Get T2 (dephasing time) for qubit 0\n", " t2 = properties.t2(0)\n", " print(f\"Qubit 0 T2 (dephasing time): {t2}\")\n", "\n", " # Get readout error for qubit 0\n", " readout_error = properties.readout_error(0)\n", " print(f\"Qubit 0 readout error: {readout_error}\")\n", "\n", " # Get all properties for a specific qubit\n", " print(\"All properties for qubit 0:\")\n", " qubit_props = properties.qubit_property(0)\n", " for prop_name, prop_value in qubit_props.items():\n", " print(f\" {prop_name}: {prop_value}\")\n", "else:\n", " print(\"No properties available for this job\")" ] }, { "cell_type": "markdown", "id": "cancel-job", "metadata": {}, "source": [ "\n", "\n", "## Job abbrechen\n", "\n", "Einen Auftrag abbrechen, der in der Warteschlange steht oder gerade ausgeführt wird. Sobald ein Auftrag abgebrochen wurde, kann er nicht mehr fortgesetzt werden.\n", "\n", "\n", " \n", " Verwenden Sie die Methode `job.cancel()` , um einen Auftrag programmgesteuert abzubrechen.\n", "\n", " \n", " \n", "\n", " \n", " 1. **Aus der Tabelle „Workloads** “: Klicken Sie auf das Überlaufmenü am Ende der Zeile des Workloads, den Sie abbrechen möchten, und wählen Sie **„Abbrechen“** aus.\n", " 2. **Auf der Seite mit den Auftragsdetails** : Klicken Sie auf den Auftrag, um dessen Detailseite zu öffnen, nutzen Sie das Dropdown-Menü **„Aktionen“** oben auf der Seite und wählen Sie **„Abbrechen“** aus.\n", " \n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "cancel-code", "metadata": { "tags": [ "id-cancel" ] }, "outputs": [], "source": [ "from qiskit_ibm_runtime import QiskitRuntimeService\n", "\n", "service = QiskitRuntimeService()\n", "\n", "# Retrieve the job\n", "job = service.job(\"\")\n", "\n", "# Cancel the job\n", "job.cancel()\n", "\n", "print(f\"Job {job.job_id()} has been canceled\")" ] }, { "cell_type": "markdown", "id": "next-steps", "metadata": {}, "source": [ "\n", "\n", "## Nächste Schritte\n", "\n", "\n", " * Weitere Methoden zur Auftragsverwaltung finden Sie in der [`QiskitRuntimeService` API-Referenz](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service).\n", " * Machen Sie sich mit [den Ausführungsmodi](/docs/guides/execution-modes) vertraut, um die verschiedenen Arten von Batch- und Session-Workloads zu verstehen.\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "id": "a1b8767d", "source": "© IBM Corp., 2017-2026" } ], "metadata": { "description": "How to monitor or cancel a job submitted to IBM Quantum Platform", "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3" }, "title": "Monitor or cancel a job" }, "nbformat": 4, "nbformat_minor": 4 }