Magpatakbo ng mga job sa isang session

Mga bersyon ng package

Ang code sa pahinang ito ay ginawa gamit ang mga sumusunod na kinakailangan. Inirerekomenda naming gamitin ang mga bersyong ito o mas bago pa.

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

Tandaan

Ang mga gumagamit ng Open Plan ay hindi makakapag-submit ng mga session job. Ang mga workload ay dapat ipatakbo sa job mode o batch mode.

Gamitin ang mga session kapag kailangan mo ng dedikado at eksklusibong access sa QPU.

Pagsisimula gamit ang mga session

Bago magsimula ng session, kailangan mong i-set up ang Qiskit Runtime at i-initialize ito bilang isang service:

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

Magbukas ng session

Maaari kang magbukas ng runtime session gamit ang context manager na with Session(...) o sa pamamagitan ng pag-initialize ng klase na Session. Kapag nagbukas ka ng session, kailangan mong tukuyin ang isang QPU sa pamamagitan ng pagpasa ng backend object. Nagsisimula ang session kapag nagsimulang mag-execute ang unang job nito.

tala

Kung magbubukas ka ng session ngunit hindi mag-su-submit ng anumang job dito sa loob ng 30 minuto, awtomatikong magsasara ang session.

Session class

babala

Ang sumusunod na code block ay magbabalik ng error para sa mga gumagamit ng Open Plan dahil gumagamit ito ng mga session. Ang mga workload sa Open Plan ay maaari lamang tumakbo sa job mode o 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

Awtomatikong binubuksan at isinasara ng context manager ang session.

babala

Ang sumusunod na code block ay magbabalik ng error para sa mga gumagamit ng Open Plan dahil gumagamit ito ng mga session. Ang mga workload sa Open Plan ay maaari lamang tumakbo sa job mode o 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()

Haba ng session

Ang maximum session time to live (TTL) ang nagtatakda kung gaano katagal maaaring tumakbo ang isang session. Maaari mong itakda ang value na ito gamit ang parameter na max_time. Dapat itong lampas sa execution time ng pinakamatagal na job.

Nagsisimula ang timer na ito kapag nagsimula ang session. Kapag naabot ang value, isinasara ang session. Ang mga job na tumatakbo ay matatapos, ngunit ang mga job na naka-queue pa ay mabibigo.

babala

Ang sumusunod na code block ay magbabalik ng error para sa mga gumagamit ng Open Plan dahil gumagamit ito ng mga session. Ang mga workload sa Open Plan ay maaari lamang tumakbo sa job mode o batch mode.

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

Mayroon ding interactive time to live (interactive TTL) value na hindi maaaring i-configure. Kung walang session job na naka-queue sa loob ng window na iyon, pansamantalang dina-deactivate ang session.

Mga default na value:

Uri ng instance (Open o Premium Plan)	Interactive TTL	Maximum TTL
Premium Plan	60 sec*	8 h*
* Ang ilang Premium Plan instance ay maaaring na-configure na may ibang value.

Para malaman ang max TTL o interactive TTL ng isang session, sundin ang mga tagubilin sa Alamin ang mga detalye ng session at hanapin ang value ng max_time o interactive_timeout, ayon sa pagkakataon.

Pagtatapos ng session

Nagtatapos ang session sa mga sumusunod na sitwasyon:

• Naabot ang maximum timeout (TTL) value, na nagreresulta sa pagkansela ng lahat ng naka-queue na job.
• Manu-manong kinansela ang session, na nagreresulta sa pagkansela ng lahat ng naka-queue na job.
• Manu-manong isinara ang session. Titigil ang session sa pagtanggap ng mga bagong job ngunit patuloy na magpapatakbo ng mga naka-queue na job nang may priyoridad.
• Kung gagamitin mo ang Session bilang context manager, iyon ay with Session(), awtomatikong isinasara ang session kapag natapos ang context (parehong gawi ng paggamit ng session.close()).

Isara ang session

Awtomatikong nagsasara ang session kapag lumabas ito sa context manager. Kapag lumabas ang session context manager, inilalagay ang session sa status na "In progress, not accepting new jobs". Ibig sabihin nito, tinatapusin ng session ang pagproseso ng lahat ng tumatakbo o naka-queue na job hanggang maabot ang maximum timeout value. Pagkatapos makumpleto ang lahat ng job, agad na isinasara ang session. Nagbibigay-daan ito sa scheduler na patakbuhin ang susunod na job nang hindi naghihintay para sa interactive timeout ng session, na nagbabawas sa average na oras ng paghihintay ng job sa queue. Hindi ka makakapagsumite ng mga job sa isang saradong session.

babala

Ang sumusunod na code block ay magbabalik ng error para sa mga gumagamit ng Open Plan dahil gumagamit ito ng mga session. Ang mga workload sa Open Plan ay maaari lamang tumakbo sa job mode o 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

Kung hindi ka gumagamit ng context manager, manu-manong isara ang session para maiwasan ang hindi gustong gastos. Maaari mong isara ang session sa sandaling tapos ka na mag-submit ng mga job dito. Kapag isinara ang session gamit ang session.close(), hindi na ito tatanggap ng mga bagong job, ngunit ang mga job na na-submit na ay patuloy na tatakbo hanggang makumpleto at maaaring makuha ang kanilang mga resulta.

babala

Ang sumusunod na code block ay magbabalik ng error para sa mga gumagamit ng Open Plan dahil gumagamit ito ng mga session. Ang mga workload sa Open Plan ay maaari lamang tumakbo sa job mode o 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})

Suriin ang status ng session

Maaari kang mag-query ng status ng session para maunawaan ang kasalukuyang estado nito sa pamamagitan ng paggamit ng session.status() o sa pamamagitan ng pagtingin sa pahina ng Workloads.

Ang status ng session ay maaaring isa sa mga sumusunod:

• Pending: Hindi pa nagsimula ang session o na-deactivate ito. Ang susunod na session job ay kailangang maghintay sa queue tulad ng ibang mga job.
• In progress, accepting new jobs: Aktibo ang session at tumatanggap ng mga bagong job.
• In progress, not accepting new jobs: Aktibo ang session ngunit hindi tumatanggap ng mga bagong job. Ang pag-submit ng job sa session ay tinatanggihan, ngunit ang mga natitirang session job ay tatakbo hanggang makumpleto. Awtomatikong isinasara ang session kapag natapos ang lahat ng job.
• Closed: Naabot na ang maximum timeout value ng session o tahasang isinara ang session.

Alamin ang mga detalye ng session

Para sa komprehensibong pangkalahatang-ideya ng configuration at status ng session, gamitin ang session.details() method.

babala

Ang sumusunod na code block ay magbabalik ng error para sa mga gumagamit ng Open Plan dahil gumagamit ito ng mga session. Ang mga workload sa Open Plan ay maaari lamang tumakbo sa job mode o 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}

Mga pattern ng paggamit

Ang mga session ay kapaki-pakinabang lalo na para sa mga algorithm na nangangailangan ng madalas na komunikasyon sa pagitan ng mga klasikal at quantum na mapagkukunan.

Halimbawa: Magpatakbo ng iterative workload na gumagamit ng klasikal na SciPy optimizer para mabawasan ang isang cost function. Sa modelong ito, ginagamit ng SciPy ang output ng cost function para kalkulahin ang susunod nitong input.

babala

Ang sumusunod na code block ay magbabalik ng error para sa mga gumagamit ng Open Plan dahil gumagamit ito ng mga session. Ang mga workload sa Open Plan ay maaari lamang tumakbo sa job mode o 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()

Magpatakbo ng dalawang VQE algorithm sa isang session gamit ang threading

Maaari kang makakuha ng mas marami mula sa isang session sa pamamagitan ng pagpapatakbo ng maraming workload nang sabay-sabay. Ipinapakita ng sumusunod na halimbawa kung paano mo maaaring patakbuhin ang dalawang VQE algorithm, bawisa ay gumagamit ng ibang klasikal na optimizer, nang sabay-sabay sa loob ng iisang session. Ginagamit din ang mga job tag para mapaghiwalay ang mga job mula sa bawat workload.

babala

Ang sumusunod na code block ay magbabalik ng error para sa mga gumagamit ng Open Plan dahil gumagamit ito ng mga session. Ang mga workload sa Open Plan ay maaari lamang tumakbo sa job mode o 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()

Mga susunod na hakbang

Mga Rekomendasyon

• Subukan ang isang halimbawa sa tutorial ng Quantum approximate optimization algorithm (QAOA).
• Suriin ang sanggunian ng Session API.
• Alamin ang Mga limitasyon ng job kapag nagpapadala ng job sa isang IBM® QPU.
• Suriin ang mga FAQ sa execution modes.