Spouštění úloh v Session

Verze balíčků

Kód na této stránce byl vyvinut s použitím následujících požadavků. Doporučujeme použít tyto verze nebo novější.

qiskit[all]~=2.3.0
qiskit-ibm-runtime~=0.43.1
scipy~=1.16.3

Poznámka

Uživatelé Open Planu nemohou odesílat úlohy v Session. Workloady musí být spuštěny v job mode nebo batch mode.

Session používej tehdy, když potřebuješ vyhrazený a exkluzivní přístup k QPU.

Nastavení pro použití Session

Před spuštěním Session musíš nastavit Qiskit Runtime a inicializovat ho jako službu:

# Added by doQumentation — required packages for this notebook
!pip install -q numpy qiskit qiskit-ibm-runtime scipy

from qiskit_ibm_runtime import (
    QiskitRuntimeService,
    Session,
    SamplerV2 as Sampler,
    EstimatorV2 as Estimator,
)

service = QiskitRuntimeService()

Otevření Session

Session můžeš otevřít pomocí context manageru with Session(...) nebo inicializací třídy Session. Při spuštění Session musíš zadat QPU předáním objektu backend. Session se spustí, jakmile začne provádět svou první úlohu.

poznámka

Pokud otevřeš Session, ale po dobu 30 minut do ní neodesleš žádnou úlohu, Session se automaticky zavře.

Třída Session

pozor

Následující blok kódu vrátí chybu uživatelům Open Planu, protože používá Session. Workloady na Open Planu mohou běžet pouze v job mode nebo batch mode.

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

Context manager

Context manager automaticky otevře a zavře Session.

pozor

Následující blok kódu vrátí chybu uživatelům Open Planu, protože používá Session. Workloady na Open Planu mohou běžet pouze v job mode nebo batch mode.

from qiskit_ibm_runtime import (
    Session,
    SamplerV2 as Sampler,
    EstimatorV2 as Estimator,
)

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

Délka Session

Maximální doba životnosti Session (TTL) určuje, jak dlouho může Session běžet. Tuto hodnotu lze nastavit pomocí parametru max_time. Měla by překračovat dobu provádění nejdelší úlohy.

Tento časovač se spustí při zahájení Session. Po dosažení hodnoty se Session zavře. Všechny právě běžící úlohy budou dokončeny, ale úlohy stále ve frontě selžou.

pozor

Následující blok kódu vrátí chybu uživatelům Open Planu, protože používá Session. Workloady na Open Planu mohou běžet pouze v job mode nebo batch mode.

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

Existuje také hodnota interaktivní doby životnosti (interactive TTL), kterou nelze konfigurovat. Pokud v tomto časovém okně nejsou ve frontě žádné úlohy Session, Session se dočasně deaktivuje.

Výchozí hodnoty:

Typ instance (Open nebo Premium Plan)	Interaktivní TTL	Maximální TTL
Premium Plan	60 sec*	8 h*
* Některé instance Premium Planu mohou být nakonfigurovány na jinou hodnotu.

Chceš-li zjistit maximální TTL nebo interaktivní TTL Session, postupuj podle pokynů v části Zjištění podrobností Session a hledej hodnotu max_time, respektive interactive_timeout.

Ukončení Session

Session se ukončí v těchto situacích:

Je dosažena maximální hodnota časového limitu (TTL), což způsobí zrušení všech úloh ve frontě.
Session je ručně zrušena, což způsobí zrušení všech úloh ve frontě.
Session je ručně zavřena. Session přestane přijímat nové úlohy, ale úlohy ve frontě nadále spouští s prioritou.
Pokud použiješ Session jako context manager, tedy with Session(), Session se automaticky zavře po skončení kontextu (stejné chování jako při použití session.close()).

Zavření Session

Session se automaticky zavře, jakmile opustí context manager. Když je ukončen context manager Session, Session přejde do stavu „Probíhá, nepřijímá nové úlohy". To znamená, že Session dokončí zpracování všech běžících nebo zařazených úloh, dokud nedosáhne maximální hodnoty časového limitu. Po dokončení všech úloh se Session okamžitě zavře. To umožňuje plánovači spustit další úlohu bez čekání na interaktivní časový limit Session, čímž se zkrátí průměrná doba čekání úloh ve frontě. Do zavřené Session nelze odesílat úlohy.

pozor

Následující blok kódu vrátí chybu uživatelům Open Planu, protože používá Session. Workloady na Open Planu mohou běžet pouze v job mode nebo batch mode.

from qiskit.quantum_info import SparsePauliOp
from qiskit.circuit import QuantumCircuit, Parameter
from qiskit.transpiler import generate_preset_pass_manager
import numpy as np

# This cell is hidden from users
service = QiskitRuntimeService()
backend = service.least_busy()

# Define two circuits, each with one parameter with two parameters.
circuit = QuantumCircuit(2)
circuit.h(0)
circuit.cx(0, 1)
circuit.ry(Parameter("a"), 0)
circuit.cx(0, 1)
circuit.h(0)
circuit.measure_all()

pm = generate_preset_pass_manager(optimization_level=1, backend=backend)
transpiled_circuit = pm.run(circuit)
transpiled_circuit_sampler = transpiled_circuit
transpiled_circuit_sampler.measure_all()

# Create parameters and mapped observables to submit
params = np.random.uniform(size=(2, 3)).T
observables = [
    SparsePauliOp(["XX", "IY"], [0.5, 0.5]),
    SparsePauliOp("XX"),
    SparsePauliOp("IY"),
]
mapped_observables = [
    [observable.apply_layout(transpiled_circuit.layout)]
    for observable in observables
]

sampler_pub = (transpiled_circuit_sampler, params)
estimator_pub = (transpiled_circuit_sampler, mapped_observables, params)

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

tip

Pokud nepoužíváš context manager, Session ručně zavři, aby nevznikaly nežádoucí náklady. Session můžeš zavřít ihned poté, co do ní dokončíš odesílání úloh. Když je Session zavřena pomocí session.close(), již nepřijímá nové úlohy, ale již odeslané úlohy budou stále dokončeny a jejich výsledky lze načíst.

pozor

Následující blok kódu vrátí chybu uživatelům Open Planu, protože používá Session. Workloady na Open Planu mohou běžet pouze v job mode nebo batch mode.

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

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=133>), shape=(3, 2)), metadata={'circuit_metadata': {}})], metadata={'execution': {'execution_spans': ExecutionSpans([DoubleSliceSpan(<start='2026-01-15 07:53:15', stop='2026-01-15 07:53:21', size=24576>)])}, 'version': 2})

Kontrola stavu Session

Stav Session můžeš zjistit pomocí session.status() nebo zobrazením stránky Workloads.

Stav Session může být jeden z následujících:

Pending: Session nebyla spuštěna nebo byla deaktivována. Další úloha Session musí čekat ve frontě jako ostatní úlohy.
In progress, accepting new jobs: Session je aktivní a přijímá nové úlohy.
In progress, not accepting new jobs: Session je aktivní, ale nepřijímá nové úlohy. Odesílání úloh do Session je odmítnuto, ale stávající úlohy Session budou dokončeny. Session se automaticky zavře, jakmile jsou všechny úlohy dokončeny.
Closed: Byla dosažena maximální hodnota časového limitu Session nebo byla Session explicitně zavřena.

Zjištění podrobností Session

Pro komplexní přehled konfigurace a stavu Session použij metodu session.details().

pozor

Následující blok kódu vrátí chybu uživatelům Open Planu, protože používá Session. Workloady na Open Planu mohou běžet pouze v job mode nebo batch mode.

from qiskit_ibm_runtime import (
    QiskitRuntimeService,
    Session,
    EstimatorV2 as Estimator,
)

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

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

{'id': 'be84569d-86b5-4a7f-be5e-7d33e80dc220', 'backend_name': 'ibm_torino', '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}

Vzory použití

Session jsou zvláště užitečné pro algoritmy, které vyžadují časté přepínání mezi klasickými a kvantovými prostředky.

Příklad: Spusť iterativní workload, který používá klasický SciPy optimalizátor k minimalizaci nákladové funkce. V tomto modelu SciPy využívá výstup nákladové funkce k výpočtu svého dalšího vstupu.

pozor

Následující blok kódu vrátí chybu uživatelům Open Planu, protože používá Session. Workloady na Open Planu mohou běžet pouze v job mode nebo batch mode.

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

Spuštění dvou algoritmů VQE v Session pomocí vláken

Ze Session lze vytěžit více tím, že spustíš více workloadů současně. Následující příklad ukazuje, jak můžeš současně spustit dva algoritmy VQE, každý s jiným klasickým optimalizátorem, uvnitř jediné Session. K rozlišení úloh z různých workloadů se používají také tagy úloh.

pozor

Následující blok kódu vrátí chybu uživatelům Open Planu, protože používá Session. Workloady na Open Planu mohou běžet pouze v job mode nebo batch mode.

from concurrent.futures import ThreadPoolExecutor
from qiskit_ibm_runtime import EstimatorV2 as 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()

Další kroky

Doporučení

Vyzkoušej příklad v tutoriálu Quantum approximate optimization algorithm (QAOA).
Prohlédni si referenci Session API.
Pochop limity úloh při odesílání úlohy na QPU IBM®.
Prohlédni si FAQ k execution modes.

Nastavení pro použití Session​

Otevření Session​

Délka Session​

Ukončení Session​

Zavření Session​

Kontrola stavu Session​

Zjištění podrobností Session​

Vzory použití​

Spuštění dvou algoritmů VQE v Session pomocí vláken​

Další kroky​

Nastavení pro použití Session

Otevření Session

Délka Session

Ukončení Session

Zavření Session

Kontrola stavu Session

Zjištění podrobností Session

Vzory použití

Spuštění dvou algoritmů VQE v Session pomocí vláken

Další kroky