Jobs in einer Sitzung ausführen

• Paketversionen

  Der Code auf dieser Seite wurde unter Berücksichtigung der folgenden Anforderungen entwickelt. Wir empfehlen die Verwendung dieser oder neuerer Versionen.

  qiskit[all]~=2.5.2
  qiskit-ibm-runtime~=0.47.0
  scipy~=1.17.1
  

Verwenden Sie Sitzungen, wenn Sie einen speziellen und exklusiven Zugang zur QPU benötigen.

Einrichten für die Verwendung von Sitzungen

Bevor Sie eine Sitzung starten, müssen Sie den „ IBM Quantum “-Compute-Client einrichten und als Dienst initialisieren:

from qiskit_ibm_runtime import QiskitRuntimeService, Session, Executor

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Sampler, Estimator

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_sampler import Sampler
from qiskit_ibm_runtime.executor_estimator import Estimator

service = QiskitRuntimeService()

Eine Sitzung öffnen

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.

Klasse der Sitzung

backend = service.least_busy(operational=True, simulator=False)
session = Session(backend=backend)
estimator = Estimator(mode=session)
sampler = Sampler(mode=session)
executor = Executor(mode=session)
# Close the session because no context manager was used.
session.close()

Kontext-Manager

Der Kontextmanager öffnet und schließt die Sitzung automatisch.

from qiskit_ibm_runtime import Session, Executor

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Sampler, Estimator

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_sampler import Sampler
from qiskit_ibm_runtime.executor_estimator import Estimator

backend = service.least_busy(operational=True, simulator=False)
with Session(backend=backend):
    estimator = Estimator()
    sampler = Sampler()
    executor = Executor()

Sitzungslänge

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.

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.

with Session(backend=backend, max_time="25m"):
  ...

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.

Standardwerte:

Um die maximale TTL oder die interaktive TTL einer Sitzung zu ermitteln, folgen Sie den Anweisungen unter Sitzungsdetails ermitteln und suchen Sie den Wert max_timebzw. interactive_timeout .

Eine Sitzung beenden

Eine Sitzung wird unter folgenden Umständen beendet:

• Die maximale Zeitüberschreitung (TTL) ist erreicht, was zum Abbruch aller Aufträge in der Warteschlange führt.
• Die Sitzung wird manuell abgebrochen, was zum Abbruch aller in der Warteschlange stehenden Aufträge führt.
• 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.
• 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()).

Eine Sitzung schließen

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.

with Session(backend=backend) as session:
    estimator = Estimator()
    sampler = Sampler()
    job1 = estimator.run([estimator_pub])
    job2 = sampler.run([sampler_pub])

# The session is no longer accepting jobs but the submitted job will run to completion.
result = job1.result()
result2 = job2.result()

session = Session(backend=backend)

# If using qiskit-ibm-runtime earlier than 0.24.0, change `mode=` to `session=`
estimator = Estimator(mode=session)
sampler = Sampler(mode=session)
job1 = estimator.run([estimator_pub])
job2 = sampler.run([sampler_pub])
print(f"Result1: {job1.result()}")
print(f"Result2: {job2.result()}")

# Manually close the session. Running and queued jobs will run to completion.
session.close()

Output:

Result1: PrimitiveResult([PubResult(data=DataBin(evs=np.ndarray(<shape=(3, 2), dtype=float64>), stds=np.ndarray(<shape=(3, 2), dtype=float64>), ensemble_standard_error=np.ndarray(<shape=(3, 2), dtype=float64>), 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})
Result2: PrimitiveResult([SamplerPubResult(data=DataBin(meas=BitArray(<shape=(3, 2), num_shots=4096, num_bits=2>), meas0=BitArray(<shape=(3, 2), num_shots=4096, num_bits=156>), shape=(3, 2)), metadata={'circuit_metadata': {}})], metadata={'execution': {'execution_spans': ExecutionSpans([DoubleSliceSpan(<start='2026-09-01 08:34:17', stop='2026-09-01 08:34:24', size=24576>)])}, 'version': 2})

Sitzungsstatus überprüfen

Sie können den Status einer Sitzung abfragen, um ihren aktuellen Zustand zu verstehen, indem Sie session.status() verwenden oder die Seite Workloads anzeigen.

Der Sitzungsstatus kann einer der folgenden sein:

• Pending: Die Sitzung ist nicht gestartet oder wurde deaktiviert. Der nächste Sitzungsauftrag muss wie andere Aufträge in der Warteschlange warten.
• In progress, accepting new jobs: Die Sitzung ist aktiv und nimmt neue Aufträge an.
• 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.
• Closed: Der maximale Timeout-Wert der Sitzung wurde erreicht oder die Sitzung wurde explizit geschlossen.

Sitzungsdetails festlegen

Einen umfassenden Überblick über die Konfiguration und den Status einer Sitzung erhalten Sie unter session.details() method.

from qiskit_ibm_runtime import QiskitRuntimeService, Session

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Estimator

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_estimator import Estimator

service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)

with Session(backend=backend) as session:
    print(session.details())

Output:

{'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}

Verwendungsmuster

Sitzungen sind besonders nützlich für Algorithmen, die eine häufige Kommunikation zwischen klassischen und Quantenressourcen erfordern.

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.

from scipy.optimize import minimize
from qiskit.circuit.library import efficient_su2


def cost_func(params, ansatz, hamiltonian, estimator):
    # Return estimate of energy from estimator

    energy = sum(
        estimator.run([(ansatz, hamiltonian, params)]).result()[0].data.evs
    )
    return energy


hamiltonian = SparsePauliOp.from_list(
    [("YZ", 0.3980), ("ZI", -0.3980), ("ZZ", -0.0113), ("XX", 0.1810)]
)
su2_ansatz = efficient_su2(hamiltonian.num_qubits)
pm = generate_preset_pass_manager(backend=backend, optimization_level=3)
ansatz = pm.run(su2_ansatz)
mapped_hamiltonian = [
    operator.apply_layout(ansatz.layout) for operator in hamiltonian
]

num_params = ansatz.num_parameters
x0 = 2 * np.pi * np.random.random(num_params)

session = Session(backend=backend)


# If using qiskit-ibm-runtime earlier than 0.24.0, change `mode=` to `session=`
estimator = Estimator(mode=session, options={"default_shots": int(1e4)})
res = minimize(
    cost_func,
    x0,
    args=(ansatz, mapped_hamiltonian, estimator),
    method="cobyla",
    options={"maxiter": 25},
)

# Close the session because no context manager was used.
session.close()

Führen Sie zwei VQE-Algorithmen in einer Sitzung mithilfe von Threading aus

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.

from concurrent.futures import ThreadPoolExecutor

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Estimator

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_estimator import Estimator


def minimize_thread(estimator, method):
    return minimize(
        cost_func,
        x0,
        args=(ansatz, mapped_hamiltonian, estimator),
        method=method,
        options={"maxiter": 25},
    )


with Session(backend=backend), ThreadPoolExecutor() as executor:
    estimator1 = Estimator()
    estimator2 = Estimator()

    # Use different tags to differentiate the jobs.
    estimator1.options.environment.job_tags = ["cobyla"]
    estimator2.options.environment.job_tags = ["nelder-mead"]

    # Submit the two workloads.
    cobyla_future = executor.submit(minimize_thread, estimator1, "cobyla")
    nelder_mead_future = executor.submit(
        minimize_thread, estimator2, "nelder-mead"
    )

    # Get workload results.
    cobyla_result = cobyla_future.result()
    nelder_mead_result = nelder_mead_future.result()

Nächste Schritte