Přeskočit na hlavní obsah
Tento projekt je v betě. Našel jsi chybu? Otevřít issue na GitHubu. Máš otázku nebo nápad? Zeptej se v Discussions — rádi si poslechneme tvou zpětnou vazbu!
Jaká je kvalita překladu na této stránce?

Spouštění úloh 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.5.2
qiskit-ibm-runtime~=0.47.0

Použij batch mode 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 klienta IBM Quantum Compute a inicializovat ho jako službu:

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

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)
executor = Executor(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, 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()

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), kterou 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 instanceVýchozí maximální TTL
Všechny placené plány8 hodin
Open10 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, respektive 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)
poznámka

Následující kód vyžaduje, abys doplnil vlastní informace, jako jsou PUB pro Estimator a Sampler a 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()
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=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})

Zjištění podrobností o dávce​

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

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 obvodů na více úloh a spustit je jako dávku, aby se využilo paralelního zpracování.

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

Pokud nastavíš backend=backend v primitivu, program se spustí v job mode, 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í
Zdroj: Dokumentace IBM Quantum — aktualizováno 7. 11. 2026
Anglická verze na doQumentation — aktualizováno 7. 11. 2026
Problém s webem nebo překladem?Problém v obsahu? Upravit v IBM Quantum docs