Jalankan kerja dalam Session
Versi pakej
Kod pada halaman ini dibangunkan menggunakan keperluan berikut. Kami mengesyorkan penggunaan versi ini atau yang lebih baharu.
qiskit[all]~=2.3.0
qiskit-ibm-runtime~=0.43.1
scipy~=1.16.3
Gunakan Session apabila anda memerlukan akses eksklusif dan khusus kepada QPU.
Persediaan untuk menggunakan Session​
Sebelum memulakan Session, anda perlu menyediakan Qiskit Runtime dan memulakannya sebagai perkhidmatan:
# 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()
Buka Session​
Anda boleh membuka Session runtime dengan menggunakan pengurus konteks with Session(...) atau dengan memulakan kelas Session. Apabila anda memulakan Session, anda mesti menentukan QPU dengan menghantar objek backend. Session bermula apabila kerja pertamanya mula dilaksanakan.
Jika anda membuka Session tetapi tidak menghantar sebarang kerja kepadanya selama 30 minit, Session akan ditutup secara automatik.
Kelas Session
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()
Pengurus konteks
Pengurus konteks secara automatik membuka dan menutup Session.
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()
Tempoh Session​
Masa hidup maksimum (TTL) Session menentukan berapa lama Session boleh berjalan. Anda boleh menetapkan nilai ini dengan parameter max_time. Ini hendaklah melebihi masa pelaksanaan kerja yang paling lama.
Pemasa ini bermula apabila Session dimulakan. Apabila nilai dicapai, Session ditutup. Mana-mana kerja yang sedang berjalan akan selesai, tetapi kerja yang masih dalam giliran akan digagalkan.
with Session(backend=backend, max_time="25m"):
...
Terdapat juga nilai masa hidup interaktif (interactive TTL) yang tidak boleh dikonfigurasi. Jika tiada kerja Session dalam giliran dalam tempoh tersebut, Session akan dinyahaktifkan sementara.
Nilai lalai:
| Jenis instans (Pelan Open atau Premium) | Interactive TTL | TTL Maksimum |
|---|---|---|
| Pelan Premium | 60 saat* | 8 j* |
| * Sesetengah instans Pelan Premium mungkin dikonfigurasi dengan nilai yang berbeza. |
Untuk menentukan max TTL atau interactive TTL Session, ikuti arahan dalam Tentukan butiran Session dan cari nilai max_time atau interactive_timeout.
Tamatkan Session​
Session tamat dalam keadaan berikut:
- Nilai tamat masa maksimum (TTL) dicapai, menyebabkan pembatalan semua kerja dalam giliran.
- Session dibatalkan secara manual, menyebabkan pembatalan semua kerja dalam giliran.
- Session ditutup secara manual. Session berhenti menerima kerja baharu tetapi terus menjalankan kerja dalam giliran dengan keutamaan.
- Jika anda menggunakan Session sebagai pengurus konteks, iaitu
with Session(), Session ditutup secara automatik apabila konteks berakhir (tingkah laku yang sama seperti menggunakansession.close()).
Tutup Session​
Session ditutup secara automatik apabila ia keluar dari pengurus konteks. Apabila pengurus konteks Session ditamatkan, Session diletakkan dalam status "Sedang berjalan, tidak menerima kerja baharu". Ini bermakna Session menyelesaikan semua kerja yang sedang berjalan atau dalam giliran sehingga nilai tamat masa maksimum dicapai. Selepas semua kerja selesai, Session ditutup dengan segera. Ini membolehkan penjadual menjalankan kerja seterusnya tanpa menunggu tamat masa interaktif Session, dengan itu mengurangkan purata masa beratur kerja. Anda tidak boleh menghantar kerja ke Session yang telah ditutup.
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()
Jika anda tidak menggunakan pengurus konteks, tutup Session secara manual untuk mengelakkan kos yang tidak diingini. Anda boleh menutup Session sebaik sahaja anda selesai menghantar kerja kepadanya. Apabila Session ditutup dengan session.close(), ia tidak lagi menerima kerja baharu, tetapi kerja yang telah dihantar akan tetap berjalan hingga selesai dan keputusannya boleh diambil semula.
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})
Semak status Session​
Anda boleh menanya status Session untuk memahami keadaan semasanya dengan menggunakan session.status() atau dengan melihat halaman Beban Kerja.
Status Session boleh menjadi salah satu daripada berikut:
Pending: Session belum bermula atau telah dinyahaktifkan. Kerja Session seterusnya perlu menunggu dalam giliran seperti kerja lain.In progress, accepting new jobs: Session aktif dan menerima kerja baharu.In progress, not accepting new jobs: Session aktif tetapi tidak menerima kerja baharu. Penghantaran kerja ke Session ditolak, tetapi kerja Session yang belum selesai akan berjalan hingga tamat. Session ditutup secara automatik setelah semua kerja selesai.Closed: Nilai tamat masa maksimum Session telah dicapai atau Session telah ditutup secara eksplisit.
Tentukan butiran Session​
Untuk gambaran keseluruhan yang menyeluruh tentang konfigurasi dan status Session, gunakan kaedah session.details().
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}
Corak penggunaan​
Session amat berguna untuk algoritma yang memerlukan komunikasi kerap antara sumber klasik dan kuantum.
Contoh: Jalankan beban kerja berulang yang menggunakan pengoptimum SciPy klasik untuk meminimumkan fungsi kos. Dalam model ini, SciPy menggunakan output fungsi kos untuk mengira input seterusnya.
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()
Jalankan dua algoritma VQE dalam Session menggunakan threading​
Anda boleh memaksimumkan penggunaan Session dengan menjalankan berbilang beban kerja serentak. Contoh berikut menunjukkan cara anda boleh menjalankan dua algoritma VQE, masing-masing menggunakan pengoptimum klasik yang berbeza, serentak dalam satu Session. Tag kerja juga digunakan untuk membezakan kerja dari setiap beban kerja.
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()
Langkah seterusnya​
- Cuba contoh dalam tutorial Algoritma pengoptimuman anggaran kuantum (QAOA).
- Semak rujukan Session API.
- Fahami Had kerja apabila menghantar kerja ke QPU IBM®.
- Semak Soalan lazim mod pelaksanaan.