Spouštět úlohy v dávce

Verze balíčků

Kód na této stránce byl vyvinut s použitím následujících závislostí. Doporučujeme používat tyto verze nebo novější.

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

Použij dávkový režim pro současné odesílání více primitivních úloh. Níže najdeš příklady práce s dávkami.

Nastavení pro používání dávek

Před spuštěním dávky musíš nastavit Qiskit Runtime a inicializovat ho jako službu:

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

Otevření dávky

Runtime dávku můžeš otevřít pomocí správce kontextu with Batch(...) nebo inicializací třídy Batch. Při spuštění dávky musíš zadat QPU předáním objektu backend. Dávka se spustí, jakmile začne první úloha.

Třída 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()

Správce kontextu

Správce kontextu automaticky otevře a zavře dávku.

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

Délka dávky

Maximální dobu životnosti (TTL) dávky můžeš definovat pomocí parametru max_time. Tato hodnota by měla přesáhnout dobu provádění nejdelší úlohy. Časovač se spustí při zahájení dávky. Po dosažení hodnoty se dávka uzavře. Úlohy, které právě běží, se dokončí, ale úlohy stále ve frontě selžou.

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

Existuje také hodnota interaktivní doby životnosti (interactive TTL), která nelze konfigurovat (1 minuta pro všechny plány). Pokud v tomto okně není zařazena žádná dávková úloha do fronty, dávka je dočasně deaktivována.

Výchozí maximální hodnoty TTL:

Typ instance	Výchozí maximální TTL
Všechny placené plány	8 hodin
Open	10 minut

Pro zjištění maximálního TTL nebo interaktivního TTL dávky postupuj podle pokynů v části Zjistit podrobnosti o dávce a hledej hodnotu max_time nebo interactive_timeout.

Zavření dávky

Dávka se automaticky zavře při opuštění správce kontextu. Když je správce kontextu dávky ukončen, dávka přejde do stavu „Probíhá, nepřijímá nové úlohy". To znamená, že dávka dokončí zpracování všech spuštěných nebo zařazených úloh, dokud není dosaženo maximální hodnoty TTL. Po dokončení všech úloh se dávka okamžitě uzavře. Do uzavřené dávky nelze odesílat úlohy.

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

Pokud nepoužíváš správce kontextu, zavři dávku ručně. Pokud dávku necháš otevřenou a později do ní odešleš další úlohy, je možné, že maximální TTL bude dosaženo dříve, než tyto úlohy začnou běžet, a budou zrušeny. Dávku můžeš zavřít hned poté, co dokončíš odesílání úloh. Když je dávka uzavřena pomocí batch.close(), nepřijímá již nové úlohy, ale již odeslané úlohy se dokončí a jejich výsledky lze získat.

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

Zjistit podrobnosti o dávce

Pro komplexní přehled konfigurace a stavu dávky, včetně interaktivního a maximálního TTL, použij metodu 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}

Překonfigurování úloh pro paralelní zpracování

Existuje několik způsobů, jak překonfigurovat úlohy, aby využívaly paralelní zpracování poskytované dávkováním. Následující příklad ukazuje, jak lze rozdělit dlouhý seznam Circuit na více úloh a spustit je jako dávku, aby se využilo paralelního zpracování.

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)

pozor

Pokud nastavíš backend=backend v primitivu, program se spustí v režimu úlohy, i když je uvnitř kontextu dávky nebo Session. Nastavení backend=backend je zastaralé od Qiskit Runtime v0.24.0. Místo toho použij parametr mode.

Další kroky

Doporučení

• Vyzkoušej příklad v tutoriálu Kombinování možností zmírňování chyb s primitivem Estimator.
• Prohlédni si referenci Batch API.
• Pochop limity úloh při odesílání úlohy na IBM QPU.
• Projdi si FAQ k režimům provádění.