Eseguire i lavori in batch

• Versioni del pacchetto

  Il codice presente in questa pagina è stato sviluppato utilizzando i seguenti requisiti. Si consiglia di utilizzare queste versioni o versioni più recenti.

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

Utilizzare la modalità batch per inviare più lavori primitivi contemporaneamente. Di seguito sono riportati alcuni esempi di lavoro con i batch.

Configurazione per l'utilizzo dei batch

Prima di avviare un batch, è necessario configurare il client Compute di IBM Quantum e inizializzarlo come servizio:

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


service = QiskitRuntimeService()

Apri un lotto

È possibile aprire un batch di runtime utilizzando il gestore di contesto with Batch(...) o inizializzando la classe Batch classe. Quando si avvia un batch, è necessario specificare una QPU passando un oggetto backend . Il batch si avvia quando inizia l'esecuzione del primo lavoro.

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

Gestore del contesto

Il gestore del contesto apre e chiude automaticamente il batch.

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

Lunghezza del lotto

È possibile definire il tempo massimo di vita (TTL) del batch con il parametro max_time . Questo dovrebbe superare il tempo di esecuzione del lavoro più lungo. Questo timer si avvia all'avvio del batch. Quando il valore viene raggiunto, il lotto viene chiuso. I lavori in corso vengono terminati, mentre quelli ancora in coda non riescono.

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

Esiste anche un valore di time to live interattivo (TTL interattivo) che non può essere configurato (1 minuto per tutti i piani). Se non vengono accodati lavori batch entro tale finestra, il batch viene temporaneamente disattivato.

Valori TTL massimi predefiniti:

Per determinare il TTL massimo o il TTL interattivo di un batch, seguire le istruzioni in Determinare i dettagli del batch e cercare il valore max_time o interactive_timeout , rispettivamente.

Chiudi un batch

Un batch si chiude automaticamente quando esce dal gestore del contesto. Quando si esce dal gestore del contesto batch, il batch viene messo nello stato "In corso, non accetta nuovi lavori". Ciò significa che il batch termina l'elaborazione di tutti i lavori in esecuzione o in coda fino al raggiungimento del valore TTL massimo. Una volta completati tutti i lavori, il batch viene immediatamente chiuso. Non è possibile inviare lavori a un batch chiuso.

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

Determinare i dettagli del lotto

Per una panoramica completa della configurazione e dello stato di un batch, compreso il suo TTL interattivo e massimo, si può usare il sito 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}

Riconfigurare i lavori per l'elaborazione parallela

Esistono diversi modi per riconfigurare i lavori per sfruttare l'elaborazione parallela fornita dal batching. L'esempio seguente mostra come sia possibile suddividere un lungo elenco di circuiti in più lavori ed eseguirli come batch per sfruttare l'elaborazione parallela.

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)

Passi successivi