Jalankan jobs dalam batch

Versi paket

Kode di halaman ini dikembangkan menggunakan requirements berikut. Kami menyarankan untuk menggunakan versi ini atau yang lebih baru.

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

Gunakan mode batch untuk mengirimkan beberapa primitive jobs sekaligus. Berikut adalah contoh-contoh cara bekerja dengan batch.

Persiapan untuk menggunakan batch

Sebelum memulai batch, kamu harus menyiapkan Qiskit Runtime dan menginisialisasinya sebagai service:

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

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

service = QiskitRuntimeService()

Buka batch

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

Class Batch

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

Context manager

Context manager secara otomatis membuka dan menutup batch.

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

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

Durasi batch

Kamu bisa menentukan waktu hidup maksimum (TTL) batch dengan parameter max_time. Nilai ini harus melebihi waktu eksekusi job terlama. Timer ini dimulai saat batch dimulai. Ketika nilai tersebut tercapai, batch ditutup. Jobs yang sedang berjalan akan selesai, tapi jobs yang masih antre akan digagalkan.

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

Ada juga nilai interactive time to live (interactive TTL) yang tidak bisa dikonfigurasi (1 menit untuk semua plan). Jika tidak ada batch jobs yang masuk antre dalam jendela waktu tersebut, batch akan dinonaktifkan sementara.

Nilai TTL maksimum default:

Tipe instance	TTL Maksimum Default
Semua plan berbayar	8 jam
Open	10 menit

Untuk mengetahui TTL maksimum atau interactive TTL suatu batch, ikuti petunjuk di Tentukan detail batch dan cari nilai max_time atau interactive_timeout.

Tutup batch

Batch otomatis ditutup saat keluar dari context manager. Ketika context manager batch keluar, batch masuk ke status "Sedang berjalan, tidak menerima jobs baru". Artinya batch terus memproses semua jobs yang sedang berjalan atau masih antre sampai nilai TTL maksimum tercapai. Setelah semua jobs selesai, batch langsung ditutup. Kamu tidak bisa mengirimkan jobs ke batch yang sudah 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()

params = np.random.uniform(size=(2, 3)).T
observables = [
    [
        SparsePauliOp(["XX", "IY"], [0.5, 0.5]).apply_layout(
            transpiled_circuit.layout
        )
    ],
    [SparsePauliOp("XX").apply_layout(transpiled_circuit.layout)],
    [SparsePauliOp("IY").apply_layout(transpiled_circuit.layout)],
]

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

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

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

tips

Jika tidak menggunakan context manager, tutup batch secara manual. Jika kamu membiarkan batch terbuka dan mengirimkan lebih banyak jobs ke dalamnya nanti, ada kemungkinan TTL maksimum tercapai sebelum jobs berikutnya mulai berjalan, sehingga jobs tersebut dibatalkan. Kamu bisa menutup batch segera setelah selesai mengirimkan jobs ke dalamnya. Ketika batch ditutup dengan batch.close(), batch tidak lagi menerima jobs baru, tapi jobs yang sudah dikirimkan tetap akan berjalan hingga selesai dan hasilnya bisa diambil.

batch = Batch(backend=backend)

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

# Manually close the batch. Running and queued jobs will run to completion.
batch.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:47:58', stop='2026-01-15 07:48:05', size=24576>)])}, 'version': 2})

Tentukan detail batch

Untuk gambaran lengkap konfigurasi dan status batch, termasuk interactive dan max TTL-nya, gunakan metode batch.details().

from qiskit_ibm_runtime import (
    QiskitRuntimeService,
    batch,
    SamplerV2 as Sampler,
)

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

with Batch(backend=backend) as batch:
    print(batch.details())

{'id': 'ce8cf08d-b18e-4d56-ab51-eaff0b8190f4', 'backend_name': 'ibm_torino', 'interactive_timeout': 1, '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': 'batch', 'usage_time': None}

Konfigurasi ulang jobs untuk pemrosesan paralel

Ada beberapa cara untuk mengkonfigurasi ulang jobs agar memanfaatkan pemrosesan paralel yang disediakan oleh batching. Contoh berikut menunjukkan cara mempartisi daftar Circuit yang panjang menjadi beberapa jobs dan menjalankannya sebagai batch untuk memanfaatkan pemrosesan paralel.

from qiskit_ibm_runtime import SamplerV2 as Sampler, Batch
from qiskit.circuit.random import random_circuit

max_circuits = 100
circuits = [pm.run(random_circuit(5, 5)) for _ in range(5 * max_circuits)]
for circuit in circuits:
    circuit.measure_active()
all_partitioned_circuits = []
for i in range(0, len(circuits), max_circuits):
    all_partitioned_circuits.append(circuits[i : i + max_circuits])
jobs = []
start_idx = 0

with Batch(backend=backend):
    sampler = Sampler()
    for partitioned_circuits in all_partitioned_circuits:
        job = sampler.run(partitioned_circuits)
        jobs.append(job)

perhatian

Jika kamu menetapkan backend=backend dalam primitive, program dijalankan dalam mode job, meskipun berada di dalam konteks batch atau Session. Penggunaan backend=backend sudah deprecated sejak Qiskit Runtime v0.24.0. Sebagai gantinya, gunakan parameter mode.

Langkah selanjutnya

Rekomendasi

• Coba contoh di tutorial Kombinasikan opsi mitigasi error dengan estimator primitive.
• Tinjau referensi Batch API.
• Pahami Batas job saat mengirimkan job ke IBM QPU.
• Tinjau FAQ mode eksekusi.