{ "cells": [ { "cell_type": "markdown", "id": "b9fd7c5e-f3b8-4f0d-8632-821d601af52c", "metadata": {}, "source": [ "---\n", "title: \"Jobs in einer Sitzung ausführen\"\n", "description: \"So führen Sie einen Quantencomputing-Auftrag in einer Sitzung des „ IBM Quantum “ Compute Service aus.\"\n", "---\n", "\n", "\n", "\n", "# Jobs in einer Sitzung ausführen\n", "\n" ] }, { "cell_type": "markdown", "id": "817c70e7-29dd-4f70-85ad-6487d7c4b010", "metadata": { "tags": [ "version-info" ] }, "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 die Verwendung dieser oder neuerer Versionen.\n", "\n", " ```\n", " qiskit[all]~=2.5.2\n", " qiskit-ibm-runtime~=0.47.0\n", " scipy~=1.17.1\n", " ```\n", " \n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "be06e0ee-e593-4fe7-aa98-4f6e0dcbaa9f", "metadata": {}, "source": [ "\n", " Open-Plan-Benutzer können keine Sitzungsaufträge einreichen. Die Workloads müssen im [Job-](/docs/guides/execution-modes#job-mode) oder [Batch-Modus](/docs/guides/execution-modes#batch-mode) ausgeführt werden.\n", "\n", "\n", "Verwenden Sie Sitzungen, wenn Sie einen speziellen und exklusiven Zugang zur QPU benötigen.\n", "\n", "\n", "\n", "## Einrichten für die Verwendung von Sitzungen\n", "\n", "Bevor Sie eine Sitzung starten, müssen Sie [den „ IBM Quantum “-Compute-Client einrichten](/docs/guides/install-qiskit-runtime) und als Dienst initialisieren:\n", "\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "117d0471-1f98-489c-906f-8aab836cd877", "metadata": {}, "outputs": [], "source": [ "from qiskit_ibm_runtime import QiskitRuntimeService, Session, Executor\n", "\n", "# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0\n", "# from qiskit_ibm_runtime import Sampler, Estimator\n", "\n", "# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0\n", "from qiskit_ibm_runtime.executor_sampler import Sampler\n", "from qiskit_ibm_runtime.executor_estimator import Estimator\n", "\n", "service = QiskitRuntimeService()" ] }, { "cell_type": "markdown", "id": "1e1cd9a3-7f36-4f42-8924-7f4dac202788", "metadata": {}, "source": [ "\n", "\n", "## Eine Sitzung öffnen\n", "\n", "Sie können eine Laufzeitsitzung mit Hilfe des Kontextmanagers `with Session(...)` oder durch Initialisierung der `Session` klasse. Wenn Sie eine Sitzung starten, müssen Sie eine QPU angeben, indem Sie ein `backend` Objekt übergeben. Die Sitzung beginnt, wenn der erste Auftrag ausgeführt wird.\n", "\n", "\n", " Wenn Sie eine Sitzung öffnen, aber 30 Minuten lang keine Aufträge an die Sitzung übermitteln, wird die Sitzung automatisch geschlossen.\n", "\n", "\n", "**Klasse der Sitzung**\n", "\n", "\n", " Der folgende Codeblock gibt einen Fehler für Benutzer auf dem offenen Plan zurück, da er Sitzungen verwendet. Workloads auf dem Open Plan können nur im [Auftragsmodus](/docs/guides/execution-modes#job-mode) oder im [Batch-Modus](/docs/guides/execution-modes#batch-mode) laufen.\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "2694bd4c-2011-4671-9625-3e7e941dd381", "metadata": {}, "outputs": [], "source": [ "backend = service.least_busy(operational=True, simulator=False)\n", "session = Session(backend=backend)\n", "estimator = Estimator(mode=session)\n", "sampler = Sampler(mode=session)\n", "executor = Executor(mode=session)\n", "# Close the session because no context manager was used.\n", "session.close()" ] }, { "cell_type": "markdown", "id": "e0460f64-f5a8-4663-834a-a4c15c9ad82b", "metadata": {}, "source": [ "**Kontext-Manager**\n", "\n", "Der Kontextmanager öffnet und schließt die Sitzung automatisch.\n", "\n", "\n", " Der folgende Codeblock gibt einen Fehler für Benutzer auf dem offenen Plan zurück, da er Sitzungen verwendet. Workloads auf dem Open Plan können nur im [Auftragsmodus](/docs/guides/execution-modes#job-mode) oder im [Batch-Modus](/docs/guides/execution-modes#batch-mode) laufen.\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "192e5e57-2f9d-4f8e-b3e7-1dd31907e8a6", "metadata": {}, "outputs": [], "source": [ "from qiskit_ibm_runtime import Session, Executor\n", "\n", "# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0\n", "# from qiskit_ibm_runtime import Sampler, Estimator\n", "\n", "# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0\n", "from qiskit_ibm_runtime.executor_sampler import Sampler\n", "from qiskit_ibm_runtime.executor_estimator import Estimator\n", "\n", "backend = service.least_busy(operational=True, simulator=False)\n", "with Session(backend=backend):\n", " estimator = Estimator()\n", " sampler = Sampler()\n", " executor = Executor()" ] }, { "cell_type": "markdown", "id": "e4219769-6348-4d0c-8e13-830177a4e7b8", "metadata": {}, "source": [ "\n", "\n", "\n", "\n", "## Sitzungslänge\n", "\n", "Die maximale Lebensdauer einer Sitzung (TTL) bestimmt, wie lange eine Sitzung laufen kann. Sie können diesen Wert mit dem Parameter `max_time` einstellen. Diese sollte die längste Ausführungszeit des Auftrags übersteigen.\n", "\n", "Dieser Timer startet, wenn die Sitzung beginnt. Wenn der Wert erreicht ist, wird die Sitzung beendet. Laufende Aufträge werden beendet, aber Aufträge, die noch in der Warteschlange stehen, werden nicht ausgeführt.\n", "\n", "\n", " Der folgende Codeblock gibt einen Fehler für Benutzer auf dem offenen Plan zurück, da er Sitzungen verwendet. Workloads auf dem Open Plan können nur im [Auftragsmodus](/docs/guides/execution-modes#job-mode) oder im [Batch-Modus](/docs/guides/execution-modes#batch-mode) laufen.\n", "\n", "\n", "```python\n", "with Session(backend=backend, max_time=\"25m\"):\n", " ...\n", "```\n", "\n", "Außerdem gibt es einen interaktiven TTL-Wert (Time to Live), der nicht konfiguriert werden kann. Wenn innerhalb dieses Zeitfensters keine Sitzungsaufträge in die Warteschlange gestellt werden, wird die Sitzung vorübergehend deaktiviert.\n", "\n", "Standardwerte:\n", "\n", "| Instanztyp (Open oder Premium Plan) | Interaktive TTL | Maximale Lebensdauer |\n", "| ----------------------------------------------------------------------------------------------------- | --------------- | -------------------- |\n", "| Premium-Plan | 60 sec\\* | 8 h\\* |\n", "| *\\* Bestimmte Premium-Plan-Instanzen können so konfiguriert sein, dass sie einen anderen Wert haben.* | | |\n", "\n", "Um die maximale TTL oder die interaktive TTL einer Sitzung zu ermitteln, folgen Sie den Anweisungen unter [Sitzungsdetails ermitteln](#session-details) und suchen Sie den Wert `max_time`bzw. `interactive_timeout` .\n", "\n", "\n", "\n", "\n", "\n", "## Eine Sitzung beenden\n", "\n", "Eine Sitzung wird unter folgenden Umständen beendet:\n", "\n", "* Die maximale Zeitüberschreitung (TTL) ist erreicht, was zum Abbruch aller Aufträge in der Warteschlange führt.\n", "* Die Sitzung wird manuell abgebrochen, was zum Abbruch aller in der Warteschlange stehenden Aufträge führt.\n", "* Die Sitzung wird manuell beendet. Die Sitzung nimmt keine neuen Aufträge mehr an, führt aber die Aufträge in der Warteschlange mit Priorität weiter aus.\n", "* Wenn Sie Session als Kontextmanager verwenden, d.h. `with Session()`, wird die Session automatisch geschlossen, wenn der Kontext endet (dasselbe Verhalten wie bei `session.close()`).\n", "\n", "\n", "\n", "\n", "\n", "### Eine Sitzung schließen\n", "\n", "Eine Sitzung wird automatisch beendet, wenn sie den Kontextmanager verlässt. Beim Beenden des Sitzungskontextmanagers wird die Sitzung in den Status \"In Bearbeitung, nimmt keine neuen Aufträge an\" versetzt. Das bedeutet, dass die Sitzung die Verarbeitung aller laufenden oder in der Warteschlange stehenden Aufträge abschließt, bis der maximale Timeout-Wert erreicht ist. Wenn alle Aufträge erledigt sind, wird die Sitzung sofort beendet. Dadurch kann der Scheduler den nächsten Auftrag ausführen, ohne die interaktive Zeitüberschreitung der Sitzung abzuwarten, wodurch sich die durchschnittliche Wartezeit für den Auftrag verringert. Sie können keine Aufträge für eine geschlossene Sitzung einreichen.\n", "\n", "\n", " Der folgende Codeblock gibt einen Fehler für Benutzer auf dem offenen Plan zurück, da er Sitzungen verwendet. Workloads auf dem Open Plan können nur im [Auftragsmodus](/docs/guides/execution-modes#job-mode) oder im [Batch-Modus](/docs/guides/execution-modes#batch-mode) laufen.\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "c6646bed-3064-488f-b2ff-da9ba793775a", "metadata": {}, "outputs": [], "source": [ "with Session(backend=backend) as session:\n", " estimator = Estimator()\n", " sampler = Sampler()\n", " job1 = estimator.run([estimator_pub])\n", " job2 = sampler.run([sampler_pub])\n", "\n", "# The session is no longer accepting jobs but the submitted job will run to completion.\n", "result = job1.result()\n", "result2 = job2.result()" ] }, { "cell_type": "markdown", "id": "20eb23f3-fc34-4f38-8ad7-85278ff4c823", "metadata": {}, "source": [ "\n", " Wenn Sie keinen Kontextmanager verwenden, schließen Sie die Sitzung manuell, um unerwünschte Kosten zu vermeiden. Sie können eine Sitzung schließen, sobald Sie keine Aufträge mehr an sie übermitteln. Wenn eine Sitzung mit `session.close()` geschlossen wird, nimmt sie keine neuen Aufträge mehr an, aber die bereits eingereichten Aufträge werden noch bis zum Abschluss ausgeführt und ihre Ergebnisse können abgerufen werden.\n", "\n", "\n", "\n", " Der folgende Codeblock gibt einen Fehler für Benutzer auf dem offenen Plan zurück, da er Sitzungen verwendet. Workloads auf dem Open Plan können nur im [Auftragsmodus](/docs/guides/execution-modes#job-mode) oder im [Batch-Modus](/docs/guides/execution-modes#batch-mode) laufen.\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "861cf6b3-9695-41eb-9d3d-d5293880ca75", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Result1: PrimitiveResult([PubResult(data=DataBin(evs=np.ndarray(), stds=np.ndarray(), ensemble_standard_error=np.ndarray(), shape=(3, 2)), metadata={'shots': 4096, 'target_precision': 0.015625, 'circuit_metadata': {}, 'resilience': {}, 'num_randomizations': 32})], metadata={'dynamical_decoupling': {'enable': False, 'sequence_type': 'XX', 'extra_slack_distribution': 'middle', 'scheduling_method': 'alap'}, 'twirling': {'enable_gates': False, 'enable_measure': True, 'num_randomizations': 'auto', 'shots_per_randomization': 'auto', 'interleave_randomizations': True, 'strategy': 'active-accum'}, 'resilience': {'measure_mitigation': True, 'zne_mitigation': False, 'pec_mitigation': False}, 'version': 2})\n", "Result2: PrimitiveResult([SamplerPubResult(data=DataBin(meas=BitArray(), meas0=BitArray(), shape=(3, 2)), metadata={'circuit_metadata': {}})], metadata={'execution': {'execution_spans': ExecutionSpans([DoubleSliceSpan()])}, 'version': 2})\n" ] } ], "source": [ "session = Session(backend=backend)\n", "\n", "# If using qiskit-ibm-runtime earlier than 0.24.0, change `mode=` to `session=`\n", "estimator = Estimator(mode=session)\n", "sampler = Sampler(mode=session)\n", "job1 = estimator.run([estimator_pub])\n", "job2 = sampler.run([sampler_pub])\n", "print(f\"Result1: {job1.result()}\")\n", "print(f\"Result2: {job2.result()}\")\n", "\n", "# Manually close the session. Running and queued jobs will run to completion.\n", "session.close()" ] }, { "cell_type": "markdown", "id": "aad804ed-027f-49c3-9f7d-8851a4f3de3a", "metadata": {}, "source": [ "\n", "\n", "\n", "\n", "## Sitzungsstatus überprüfen\n", "\n", "Sie können den Status einer Sitzung abfragen, um ihren aktuellen Zustand zu verstehen, indem Sie `session.status()` verwenden oder die Seite [Workloads](/workloads) anzeigen.\n", "\n", "Der Sitzungsstatus kann einer der folgenden sein:\n", "\n", "* `Pending`: Die Sitzung ist nicht gestartet oder wurde deaktiviert. Der nächste Sitzungsauftrag muss wie andere Aufträge in der Warteschlange warten.\n", "* `In progress, accepting new jobs`: Die Sitzung ist aktiv und nimmt neue Aufträge an.\n", "* `In progress, not accepting new jobs`: Die Sitzung ist aktiv, nimmt aber keine neuen Aufträge an. Die Übermittlung von Aufträgen an die Sitzung wird abgelehnt, aber ausstehende Sitzungsaufträge werden bis zum Abschluss ausgeführt. Die Sitzung wird automatisch geschlossen, sobald alle Aufträge erledigt sind.\n", "* `Closed`: Der maximale Timeout-Wert der Sitzung wurde erreicht oder die Sitzung wurde explizit geschlossen.\n", "\n", "\n", "\n", "\n", "\n", "## Sitzungsdetails festlegen\n", "\n", "Einen umfassenden Überblick über die Konfiguration und den Status einer Sitzung erhalten Sie unter `session.details() method`.\n", "\n", "\n", " Der folgende Codeblock gibt einen Fehler für Benutzer auf dem offenen Plan zurück, da er Sitzungen verwendet. Workloads auf dem Open Plan können nur im [Auftragsmodus](/docs/guides/execution-modes#job-mode) oder im [Batch-Modus](/docs/guides/execution-modes#batch-mode) laufen.\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "82a2599e-3e32-4e01-9a36-b77a56af7647", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'id': 'ff7977a5-ae7b-4509-9c84-bd1d7ff9f619', 'backend_name': 'ibm_marrakesh', 'interactive_timeout': 60, 'max_time': 28800, 'active_timeout': 28800, 'state': 'open', 'accepting_jobs': True, 'last_job_started': None, 'last_job_completed': None, 'started_at': None, 'closed_at': None, 'activated_at': None, 'mode': 'dedicated', 'usage_time': None}\n" ] } ], "source": [ "from qiskit_ibm_runtime import QiskitRuntimeService, Session\n", "\n", "# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0\n", "# from qiskit_ibm_runtime import Estimator\n", "\n", "# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0\n", "from qiskit_ibm_runtime.executor_estimator import Estimator\n", "\n", "service = QiskitRuntimeService()\n", "backend = service.least_busy(operational=True, simulator=False)\n", "\n", "with Session(backend=backend) as session:\n", " print(session.details())" ] }, { "cell_type": "markdown", "id": "7db97311-25cb-4b81-9dba-494264c554c6", "metadata": {}, "source": [ "\n", "\n", "## Verwendungsmuster\n", "\n", "Sitzungen sind besonders nützlich für Algorithmen, die eine häufige Kommunikation zwischen klassischen und Quantenressourcen erfordern.\n", "\n", "Beispiel: Führen Sie einen iterativen Workload aus, der den klassischen SciPy Optimizer verwendet, um eine Kostenfunktion zu minimieren. In diesem Modell verwendet SciPy die Ausgabe der Kostenfunktion, um die nächste Eingabe zu berechnen.\n", "\n", "\n", " Der folgende Codeblock gibt einen Fehler für Benutzer auf dem offenen Plan zurück, da er Sitzungen verwendet. Workloads auf dem Open Plan können nur im [Auftragsmodus](/docs/guides/execution-modes#job-mode) oder im [Batch-Modus](/docs/guides/execution-modes#batch-mode) laufen.\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "77cc7c96-e8c0-4970-b05e-361ddf74d707", "metadata": {}, "outputs": [], "source": [ "from scipy.optimize import minimize\n", "from qiskit.circuit.library import efficient_su2\n", "\n", "\n", "def cost_func(params, ansatz, hamiltonian, estimator):\n", " # Return estimate of energy from estimator\n", "\n", " energy = sum(\n", " estimator.run([(ansatz, hamiltonian, params)]).result()[0].data.evs\n", " )\n", " return energy\n", "\n", "\n", "hamiltonian = SparsePauliOp.from_list(\n", " [(\"YZ\", 0.3980), (\"ZI\", -0.3980), (\"ZZ\", -0.0113), (\"XX\", 0.1810)]\n", ")\n", "su2_ansatz = efficient_su2(hamiltonian.num_qubits)\n", "pm = generate_preset_pass_manager(backend=backend, optimization_level=3)\n", "ansatz = pm.run(su2_ansatz)\n", "mapped_hamiltonian = [\n", " operator.apply_layout(ansatz.layout) for operator in hamiltonian\n", "]\n", "\n", "num_params = ansatz.num_parameters\n", "x0 = 2 * np.pi * np.random.random(num_params)\n", "\n", "session = Session(backend=backend)\n", "\n", "\n", "# If using qiskit-ibm-runtime earlier than 0.24.0, change `mode=` to `session=`\n", "estimator = Estimator(mode=session, options={\"default_shots\": int(1e4)})\n", "res = minimize(\n", " cost_func,\n", " x0,\n", " args=(ansatz, mapped_hamiltonian, estimator),\n", " method=\"cobyla\",\n", " options={\"maxiter\": 25},\n", ")\n", "\n", "# Close the session because no context manager was used.\n", "session.close()" ] }, { "cell_type": "markdown", "id": "8c03c721-f040-4066-a9d2-f2dd39777789", "metadata": {}, "source": [ "\n", "\n", "\n", "\n", "## Führen Sie zwei VQE-Algorithmen in einer Sitzung mithilfe von Threading aus\n", "\n", "Sie können mehr aus einer Sitzung herausholen, wenn Sie mehrere Workloads gleichzeitig ausführen. Das folgende Beispiel zeigt, wie Sie zwei VQE-Algorithmen, die jeweils einen anderen klassischen Optimierer verwenden, gleichzeitig in einer einzigen Sitzung ausführen können. Auftrags-Tags werden auch verwendet, um Aufträge von der jeweiligen Arbeitslast zu unterscheiden.\n", "\n", "\n", " Der folgende Codeblock gibt einen Fehler für Benutzer auf dem offenen Plan zurück, da er Sitzungen verwendet. Workloads auf dem Open Plan können nur im [Auftragsmodus](/docs/guides/execution-modes#job-mode) oder im [Batch-Modus](/docs/guides/execution-modes#batch-mode) laufen.\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 9, "id": "e83f7d60-13f0-4df1-9766-6fa67c970362", "metadata": {}, "outputs": [], "source": [ "from concurrent.futures import ThreadPoolExecutor\n", "\n", "# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0\n", "# from qiskit_ibm_runtime import Estimator\n", "\n", "# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0\n", "from qiskit_ibm_runtime.executor_estimator import Estimator\n", "\n", "\n", "def minimize_thread(estimator, method):\n", " return minimize(\n", " cost_func,\n", " x0,\n", " args=(ansatz, mapped_hamiltonian, estimator),\n", " method=method,\n", " options={\"maxiter\": 25},\n", " )\n", "\n", "\n", "with Session(backend=backend), ThreadPoolExecutor() as executor:\n", " estimator1 = Estimator()\n", " estimator2 = Estimator()\n", "\n", " # Use different tags to differentiate the jobs.\n", " estimator1.options.environment.job_tags = [\"cobyla\"]\n", " estimator2.options.environment.job_tags = [\"nelder-mead\"]\n", "\n", " # Submit the two workloads.\n", " cobyla_future = executor.submit(minimize_thread, estimator1, \"cobyla\")\n", " nelder_mead_future = executor.submit(\n", " minimize_thread, estimator2, \"nelder-mead\"\n", " )\n", "\n", " # Get workload results.\n", " cobyla_result = cobyla_future.result()\n", " nelder_mead_result = nelder_mead_future.result()" ] }, { "cell_type": "markdown", "id": "0194fb4b-0917-45d7-aeb1-9fdff38cc5c5", "metadata": {}, "source": [ "\n", "\n", "## Nächste Schritte\n", "\n", "\n", " * Probieren Sie ein Beispiel aus dem Lehrgang [Quantum approximate optimization algorithm (QAOA)](/docs/tutorials/quantum-approximate-optimization-algorithm).\n", " * Lesen Sie die [Session-API-Referenz](/docs/api/qiskit-ibm-runtime/session).\n", " * Verstehen Sie die [Auftragsgrenzen](/docs/guides/job-limits) beim Senden eines Auftrags an eine IBM® QPU.\n", " * [Häufig gestellte Fragen zu Ausführungsmodi](/docs/guides/execution-modes-faq) überprüfen.\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "id": "a1b8767d", "source": "© IBM Corp., 2017-2026" } ], "metadata": { "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" } }, "nbformat": 4, "nbformat_minor": 4 }