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.3.0
qiskit-ibm-runtime~=0.43.1

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

Persediaan untuk menggunakan batch

Sebelum memulakan batch, 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

from qiskit_ibm_runtime import (
    QiskitRuntimeService,
    Batch,
    SamplerV2 as Sampler,
    EstimatorV2 as 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)
# 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,
    SamplerV2 as Sampler,
    EstimatorV2 as Estimator,
)

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

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)

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=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 butiran batch

Untuk gambaran keseluruhan yang menyeluruh tentang konfigurasi dan status batch, termasuk interactive dan max TTL-nya, gunakan kaedah 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 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_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)

awas

Jika anda menetapkan backend=backend dalam primitif, program dijalankan dalam mod kerja, walaupun ia berada dalam konteks batch atau Session. Menetapkan backend=backend telah ditamatkan 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.