Jalankan jobs dalam sebuah Session

Versi paket

Kode di halaman ini dikembangkan menggunakan persyaratan berikut. Kami sarankan menggunakan versi ini atau yang lebih baru.

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

Catatan

Pengguna Open Plan tidak bisa mengirimkan session jobs. Workload harus dijalankan dalam job mode atau batch mode.

Gunakan Session saat kamu butuh akses eksklusif dan khusus ke QPU.

Persiapan untuk menggunakan Session

Sebelum memulai sebuah Session, kamu harus menyiapkan Qiskit Runtime dan menginisialisasinya sebagai layanan:

# 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 sebuah Session

Kamu bisa membuka runtime Session menggunakan context manager with Session(...) atau dengan menginisialisasi class Session. Saat memulai Session, kamu harus menentukan QPU dengan meneruskan objek backend. Session dimulai ketika job pertamanya mulai dieksekusi.

catatan

Jika kamu membuka Session tapi tidak mengirimkan job apa pun ke dalamnya selama 30 menit, Session akan otomatis tertutup.

Class Session

perhatian

Blok kode berikut akan menghasilkan error bagi pengguna Open Plan karena menggunakan session. Workload di Open Plan hanya bisa dijalankan dalam job mode atau 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 secara otomatis membuka dan menutup Session.

perhatian

Blok kode berikut akan menghasilkan error bagi pengguna Open Plan karena menggunakan session. Workload di Open Plan hanya bisa dijalankan dalam job mode atau 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()

Durasi Session

Maksimum time to live (TTL) Session menentukan berapa lama Session bisa berjalan. Kamu bisa mengatur nilai ini dengan parameter max_time. Nilai ini harus melebihi waktu eksekusi job terlama.

Timer ini mulai berjalan saat Session dimulai. Ketika nilai tersebut tercapai, Session ditutup. Job yang sedang berjalan akan selesai, tapi job yang masih dalam antrian akan gagal.

perhatian

Blok kode berikut akan menghasilkan error bagi pengguna Open Plan karena menggunakan session. Workload di Open Plan hanya bisa dijalankan dalam job mode atau batch mode.

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

Ada juga nilai interactive time to live (interactive TTL) yang tidak bisa dikonfigurasi. Jika tidak ada session jobs yang masuk antrian dalam jendela waktu tersebut, Session akan dinonaktifkan sementara.

Nilai default:

Tipe instance (Open atau Premium Plan)	Interactive TTL	Maximum TTL
Premium Plan	60 detik*	8 jam*
* Instans Premium Plan tertentu mungkin dikonfigurasi dengan nilai yang berbeda.

Untuk mengetahui max TTL atau interactive TTL sebuah Session, ikuti petunjuk di Tentukan detail Session dan cari nilai max_time atau interactive_timeout.

Akhiri sebuah Session

Session berakhir dalam kondisi berikut:

Nilai maksimum timeout (TTL) tercapai, yang mengakibatkan pembatalan semua job dalam antrian.
Session dibatalkan secara manual, yang mengakibatkan pembatalan semua job dalam antrian.
Session ditutup secara manual. Session berhenti menerima job baru tapi tetap menjalankan job yang sudah dalam antrian dengan prioritas.
Jika kamu menggunakan Session sebagai context manager, yaitu with Session(), Session otomatis ditutup saat context berakhir (perilaku yang sama dengan menggunakan session.close()).

Tutup sebuah Session

Session secara otomatis tertutup ketika keluar dari context manager. Saat context manager Session keluar, Session masuk ke status "In progress, not accepting new jobs". Artinya Session menyelesaikan semua job yang sedang berjalan atau ada dalam antrian hingga nilai maksimum timeout tercapai. Setelah semua job selesai, Session langsung ditutup. Ini memungkinkan scheduler menjalankan job berikutnya tanpa menunggu session interactive timeout, sehingga mengurangi rata-rata waktu antrian job. Kamu tidak bisa mengirimkan job ke Session yang sudah ditutup.

perhatian

Blok kode berikut akan menghasilkan error bagi pengguna Open Plan karena menggunakan session. Workload di Open Plan hanya bisa dijalankan dalam job mode atau 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()

tips

Jika kamu tidak menggunakan context manager, tutup Session secara manual untuk menghindari biaya yang tidak diinginkan. Kamu bisa menutup Session segera setelah selesai mengirimkan job ke dalamnya. Ketika Session ditutup dengan session.close(), Session tidak lagi menerima job baru, tapi job yang sudah dikirimkan tetap akan berjalan hingga selesai dan hasilnya bisa diambil.

perhatian

Blok kode berikut akan menghasilkan error bagi pengguna Open Plan karena menggunakan session. Workload di Open Plan hanya bisa dijalankan dalam job mode atau 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})

Periksa status Session

Kamu bisa mengquery status Session untuk memahami kondisinya saat ini menggunakan session.status() atau dengan melihat halaman Workloads.

Status Session bisa berupa salah satu dari berikut:

Pending: Session belum dimulai atau sudah dinonaktifkan. Job Session berikutnya perlu menunggu dalam antrian seperti job lainnya.
In progress, accepting new jobs: Session aktif dan menerima job baru.
In progress, not accepting new jobs: Session aktif tapi tidak menerima job baru. Pengiriman job ke Session ditolak, tapi job Session yang sudah ada akan berjalan hingga selesai. Session otomatis ditutup setelah semua job selesai.
Closed: Nilai maksimum timeout Session telah tercapai atau Session ditutup secara eksplisit.

Tentukan detail Session

Untuk gambaran menyeluruh tentang konfigurasi dan status Session, gunakan metode session.details().

perhatian

Blok kode berikut akan menghasilkan error bagi pengguna Open Plan karena menggunakan session. Workload di Open Plan hanya bisa dijalankan dalam job mode atau 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}

Pola penggunaan

Session sangat berguna untuk algoritma yang memerlukan komunikasi sering antara sumber daya klasik dan kuantum.

Contoh: Jalankan workload iteratif yang menggunakan optimizer SciPy klasik untuk meminimalkan fungsi biaya. Dalam model ini, SciPy menggunakan output dari fungsi biaya untuk menghitung inputnya berikutnya.

perhatian

Blok kode berikut akan menghasilkan error bagi pengguna Open Plan karena menggunakan session. Workload di Open Plan hanya bisa dijalankan dalam job mode atau 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()

Jalankan dua algoritma VQE dalam sebuah Session menggunakan threading

Kamu bisa memaksimalkan Session dengan menjalankan beberapa workload secara bersamaan. Contoh berikut menunjukkan cara menjalankan dua algoritma VQE, masing-masing menggunakan optimizer klasik yang berbeda, secara bersamaan di dalam satu Session. Tag job juga digunakan untuk membedakan job dari setiap workload.

perhatian

Blok kode berikut akan menghasilkan error bagi pengguna Open Plan karena menggunakan session. Workload di Open Plan hanya bisa dijalankan dalam job mode atau 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()

Langkah berikutnya

Rekomendasi

Coba contoh di tutorial Quantum approximate optimization algorithm (QAOA).
Tinjau referensi Session API.
Pahami Batas Job saat mengirimkan job ke QPU IBM®.
Tinjau FAQ mode eksekusi.

Source: IBM Quantum docs — updated 27 Apr 2026

English version on doQumentation — updated 7 Mei 2026

This translation based on the English version of 11 Mar 2026

Persiapan untuk menggunakan Session​

Buka sebuah Session​

Durasi Session​

Akhiri sebuah Session​

Tutup sebuah Session​

Periksa status Session​

Tentukan detail Session​

Pola penggunaan​

Jalankan dua algoritma VQE dalam sebuah Session menggunakan threading​

Langkah berikutnya​

Persiapan untuk menggunakan Session

Buka sebuah Session

Durasi Session

Akhiri sebuah Session

Tutup sebuah Session

Periksa status Session

Tentukan detail Session

Pola penggunaan

Jalankan dua algoritma VQE dalam sebuah Session menggunakan threading

Langkah berikutnya