Magpatakbo ng mga job sa isang batch

Mga bersyon ng package

Ang code sa pahinang ito ay binuo gamit ang mga sumusunod na kinakailangan. Inirerekomenda naming gamitin ang mga bersyong ito o mas bago.

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

Gamitin ang batch mode para magsumite ng maraming primitive job nang sabay-sabay. Narito ang mga halimbawa ng paggawa sa mga batch.

I-set up para gumamit ng mga batch

Bago magsimula ng batch, kailangan mong i-set up ang Qiskit Runtime at i-initialize ito bilang isang serbisyo:

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

Buksan ang isang batch

Maaari kang magbukas ng runtime batch sa pamamagitan ng paggamit ng context manager na with Batch(...) o sa pamamagitan ng pag-initialize ng klase na Batch. Kapag nagsimula ka ng batch, kailangan mong tukuyin ang isang QPU sa pamamagitan ng pagpasa ng object na backend. Nagsisimula ang batch kapag nagsimulang mag-execute ang unang job nito.

Batch class

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

Awtomatikong binubuksan at isinasara ng context manager ang 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()

Haba ng batch

Maaari mong tukuyin ang maximum na time to live (TTL) ng batch gamit ang parameter na max_time. Dapat itong lampas pa sa execution time ng pinakamatagal na job. Nagsisimula ang timer na ito kapag nagsimula ang batch. Kapag naabot na ang value, isinasara ang batch. Anumang mga job na tumatakbo ay matatapos, ngunit ang mga job na nasa queue pa ay mabibigo.

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

Mayroon ding interactive time to live (interactive TTL) value na hindi maaaring i-configure (1 minuto para sa lahat ng plano). Kung walang batch job na naka-queue sa loob ng window na iyon, pansamantalang dina-deactivate ang batch.

Default na maximum na TTL values:

Uri ng instance	Default na Maximum TTL
Lahat ng bayad na plano	8 oras
Open	10 minuto

Para malaman ang maximum TTL o interactive TTL ng isang batch, sundin ang mga tagubilin sa Alamin ang mga detalye ng batch at hanapin ang value na max_time o interactive_timeout, ayon sa pagkakasunod.

Isara ang isang batch

Awtomatikong isinasara ang isang batch kapag lumabas ito sa context manager. Kapag lumabas na ang batch context manager, ang batch ay inilalagay sa status na "In progress, not accepting new jobs". Ibig sabihin nito, tinatapusin ng batch ang pagpoproseso ng lahat ng tumatakbo o naka-queue na job hanggang maabot ang maximum TTL value. Pagkatapos makumpleto ang lahat ng job, agad na isinasara ang batch. Hindi ka maaaring magsumite ng mga job sa isang saradong batch.

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

tip

Kung hindi ka gumagamit ng context manager, manu-manong isara ang batch. Kung iniiwan mo ang batch na bukas at nagsusumite ng mas maraming job sa ibang pagkakataon, posibleng maabot ang maximum TTL bago magsimulang tumakbo ang mga kasunod na job, na magiging sanhi ng pagkakansela ng mga ito. Maaari mong isara ang isang batch sa sandaling tapos ka nang magsumite ng mga job dito. Kapag isinara ang isang batch gamit ang batch.close(), hindi na ito tumatanggap ng mga bagong job, ngunit ang mga naisumiiteng job ay patuloy na tatakbo hanggang matapos at maaaring makuha ang kanilang mga resulta.

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

Alamin ang mga detalye ng batch

Para sa komprehensibong pangkalahatang-ideya ng configuration at status ng isang batch, kasama na ang interactive at max TTL nito, gamitin ang batch.details() method.

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}

I-reconfigure ang mga job para sa parallel processing

Maraming paraan para ma-reconfigure ang iyong mga job para mapakinabangan ang parallel processing na ibinibigay ng batching. Ipinapakita ng sumusunod na halimbawa kung paano mo maaaring i-partition ang mahabang listahan ng mga Circuit sa maraming job at patakbuhin ang mga ito bilang isang batch para mapakinabangan ang parallel processing.

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)

babala

Kung itinakda mo ang backend=backend sa isang primitive, ang programa ay pinapatakbo sa job mode, kahit na nasa loob ito ng isang batch o session context. Ang pagtakda ng backend=backend ay deprecated na simula sa Qiskit Runtime v0.24.0. Sa halip, gamitin ang parameter na mode.

Mga susunod na hakbang

Mga rekomendasyon

• Subukan ang isang halimbawa sa tutorial na Pagsasama ng mga opsyon sa error mitigation gamit ang estimator primitive.
• Suriin ang sanggunian ng Batch API.
• Alamin ang Mga limitasyon sa job kapag nagpapadala ng job sa IBM QPU.
• Suriin ang Mga FAQ sa execution modes.