Exécuter des tâches par lots

• Versions de package

  Le code figurant sur cette page a été développé selon les exigences suivantes. Nous recommandons d'utiliser ces versions ou des versions plus récentes.

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

Utilisez le mode batch pour soumettre plusieurs travaux primitifs simultanément. Les exemples suivants illustrent l'utilisation des lots.

Configurer pour utiliser des lots

Avant de lancer un traitement par lots, vous devez configurer le client Compute d’ IBM Quantum, puis l’initialiser en tant que service :

from qiskit_ibm_runtime import (
    QiskitRuntimeService,
    Batch,
    SamplerV2 as Sampler,
    EstimatorV2 as Estimator,
    Executor,
)


service = QiskitRuntimeService()

Ouvrir un lot

Vous pouvez ouvrir un lot d'exécution en utilisant le gestionnaire de contexte with Batch(...) ou en initialisant la classe Batch classe. Lorsque vous démarrez un lot, vous devez spécifier une QPU en transmettant un objet backend . Le lot démarre lorsque son premier travail commence à être exécuté.

Classe de lots

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

Gestionnaire de contexte

Le gestionnaire de contexte ouvre et ferme automatiquement le lot.

from qiskit_ibm_runtime import (
    Batch,
    SamplerV2 as Sampler,
    EstimatorV2 as Estimator,
    Executor,
)

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

Longueur du lot

Le paramètre max_time permet de définir la durée maximale de vie du lot (TTL). Cette durée doit être supérieure à la durée d'exécution du travail le plus long. Cette minuterie démarre lorsque le lot démarre. Lorsque la valeur est atteinte, le lot est clôturé. Les tâches en cours d'exécution se terminent, mais celles qui sont encore en file d'attente échouent.

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

Il existe également une valeur TTL interactive qui ne peut pas être configurée (1 minute pour tous les plans). Si aucun travail par lot n'est mis en file d'attente dans cette fenêtre, le lot est temporairement désactivé.

Valeurs maximales par défaut du TTL :

Pour déterminer le TTL maximum ou le TTL interactif d'un lot, suivez les instructions de la section Déterminer les détails du lot et recherchez la valeur max_time ou interactive_timeout , respectivement.

Fermer un lot

Un lot se ferme automatiquement lorsqu'il quitte le gestionnaire de contexte. Lorsque le gestionnaire de contexte de lot est quitté, le lot est placé dans l'état "En cours, n'acceptant pas de nouveaux travaux". Cela signifie que le lot termine le traitement de tous les travaux en cours ou en file d'attente jusqu'à ce que la valeur maximale du TTL soit atteinte. Lorsque tous les travaux sont terminés, le lot est immédiatement clôturé. Il n'est pas possible de soumettre des travaux à un lot fermé.

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

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

Output:

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-02-15 07:58:55', stop='2026-02-15 07:59:02', size=24576>)])}, 'version': 2})

Déterminer les détails du lot

Pour obtenir une vue d'ensemble de la configuration et de l'état d'un lot, y compris son TTL interactif et maximal, utilisez l'adresse 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())

Output:

{'id': '970fe01d-d2cf-45f0-b32b-f886b987a462', '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}

Reconfigurer les tâches pour le traitement parallèle

Il existe de nombreuses façons de reconfigurer vos travaux pour tirer parti du traitement parallèle offert par la mise en lots. L'exemple suivant montre comment vous pouvez diviser une longue liste de circuits en plusieurs tâches et les exécuter en tant que lot pour tirer parti du traitement parallèle.

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)

Etapes suivantes