Jalankan kerja dalam batch

Versi pakej

Kod pada halaman ini dibangunkan menggunakan keperluan berikut. Kami mengesyorkan penggunaan versi ini atau yang lebih baharu.

qiskit[all]~=2.5.2
qiskit-ibm-runtime~=0.47.0

Gunakan batch mode untuk menghantar berbilang kerja primitif serentak. Berikut adalah contoh-contoh bekerja dengan batch.

Persediaan untuk menggunakan batch

Sebelum memulakan batch, anda perlu menyediakan klien IBM Quantum Compute dan memulakannya sebagai perkhidmatan:

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"numpy": "numpy", "qiskit": "qiskit", "qiskit_ibm_runtime": "qiskit-ibm-runtime"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

from qiskit_ibm_runtime import QiskitRuntimeService, Batch, Executor

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Sampler, Estimator

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_sampler import Sampler
from qiskit_ibm_runtime.executor_estimator import Estimator

service = QiskitRuntimeService()

Buka batch

Anda boleh membuka batch runtime dengan menggunakan pengurus konteks with Batch(...) atau dengan memulakan kelas Batch. Apabila anda memulakan batch, anda mesti menentukan QPU dengan menghantar objek backend. Batch bermula apabila kerja pertamanya mula dilaksanakan.

Kelas Batch

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

Pengurus konteks

Pengurus konteks secara automatik membuka dan menutup batch.

from qiskit_ibm_runtime import Batch, Executor

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Sampler, Estimator

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_sampler import Sampler
from qiskit_ibm_runtime.executor_estimator import Estimator

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

Tempoh batch

Anda boleh menentukan masa hidup maksimum (TTL) batch dengan parameter max_time. Ini hendaklah melebihi masa pelaksanaan kerja yang paling lama. Pemasa ini bermula apabila batch dimulakan. Apabila nilai dicapai, batch ditutup. Mana-mana kerja yang sedang berjalan akan selesai, tetapi kerja yang masih dalam giliran akan digagalkan.

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

Terdapat juga nilai masa hidup interaktif (interactive TTL) yang tidak boleh dikonfigurasi (1 minit untuk semua pelan). Jika tiada kerja batch dalam giliran dalam tempoh tersebut, batch akan dinyahaktifkan sementara.

Nilai TTL maksimum lalai:

Jenis instans	TTL Maksimum Lalai
Semua pelan berbayar	8 jam
Open	10 minit

Untuk menentukan TTL maksimum atau interactive TTL batch, ikuti arahan dalam Tentukan butiran batch dan cari nilai max_time atau interactive_timeout.

Tutup batch

Batch ditutup secara automatik apabila ia keluar dari pengurus konteks. Apabila pengurus konteks batch ditamatkan, batch diletakkan dalam status "Sedang berjalan, tidak menerima kerja baharu". Ini bermakna batch menyelesaikan semua kerja yang sedang berjalan atau dalam giliran sehingga nilai TTL maksimum dicapai. Selepas semua kerja selesai, batch ditutup dengan segera. Anda tidak boleh menghantar kerja ke batch 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()

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)

nota

Kod berikut memerlukan anda membekalkan maklumat anda sendiri, seperti PUB Estimator dan Sampler, dan backend.

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

petua

Jika anda tidak menggunakan pengurus konteks, tutup batch secara manual. Jika anda membiarkan batch terbuka dan menghantar lebih banyak kerja kepadanya kemudian, ada kemungkinan TTL maksimum akan dicapai sebelum kerja seterusnya mula berjalan, menyebabkan ia dibatalkan. Anda boleh menutup batch sebaik sahaja anda selesai menghantar kerja kepadanya. Apabila batch ditutup dengan batch.close(), ia tidak lagi menerima kerja baharu, tetapi kerja yang telah dihantar akan tetap berjalan hingga selesai dan keputusannya boleh diambil semula.

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=156>), shape=(3, 2)), metadata={'circuit_metadata': {}})], metadata={'execution': {'execution_spans': ExecutionSpans([DoubleSliceSpan(<start='2026-09-01 07:46:49', stop='2026-09-01 07:46:56', size=24576>)])}, 'version': 2})

Tentukan butiran batch

Untuk gambaran keseluruhan komprehensif konfigurasi dan status batch, termasuk TTL interaktif dan maksimumnya, gunakan batch.details() method.

from qiskit_ibm_runtime import QiskitRuntimeService, Batch

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

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

{'id': '947aa097-9055-42d4-9e58-ad1c2cdd9d5a', 'backend_name': 'ibm_marrakesh', '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 semula kerja untuk pemprosesan selari

Terdapat beberapa cara anda boleh mengkonfigurasi semula kerja untuk memanfaatkan pemprosesan selari yang disediakan oleh batching. Contoh berikut menunjukkan cara anda boleh membahagikan senarai Circuit yang panjang kepada berbilang kerja dan menjalankannya sebagai batch untuk memanfaatkan pemprosesan selari.

from qiskit.circuit.random import random_circuit
from qiskit_ibm_runtime import Batch

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Sampler

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_sampler import Sampler

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)

awas

Jika anda menetapkan backend=backend dalam primitif, program dijalankan dalam job mode, walaupun ia berada dalam konteks batch atau Session. Menetapkan backend=backend telah dilapukkan sejak Qiskit Runtime v0.24.0. Sebaliknya, gunakan parameter mode.

Langkah seterusnya

Cadangan

• Cuba contoh dalam tutorial Gabungkan pilihan pengurangan ralat dengan primitif Estimator.
• Semak rujukan Batch API.
• Fahami Had kerja apabila menghantar kerja ke QPU IBM®.
• Semak Soalan lazim mod pelaksanaan.