Aller au contenu principal

Surveiller ou annuler un job

Consulte la liste de tes workloads sur la page Workloads.

Voir le statut d'un job​

Accède à ton tableau Workloads et vérifie dans la colonne Status si un job s'est terminé ou a échoué.

Voir l'utilisation restante​

Accède à ton tableau Instances et sélectionne l'onglet correspondant au plan dont tu veux consulter l'utilisation restante. Le temps total utilisé et le temps total restant sur ton plan sont affichés.

Voir les métriques sur le nombre de jobs et workloads soumis​

Accède à la page Analytics pour voir le nombre total de jobs soumis, ainsi qu'un décompte des workloads batch et des workloads de session. Note que tu ne peux voir la page Analytics que pour les comptes que tu possèdes ou gères.

Surveiller un job​

Utilise l'instance de job pour vérifier le statut du job ou récupérer les résultats en appelant la commande appropriée :

job.result()Consulte les résultats du job immédiatement après son achèvement. Les résultats sont disponibles une fois le job terminé. Par conséquent, job.result() est un appel bloquant jusqu'à la fin du job.
job.job_id()Retourne l'identifiant unique du job. Récupérer les résultats du job ultérieurement nécessite l'identifiant du job. Il est donc recommandé de sauvegarder les identifiants des jobs que tu pourrais vouloir récupérer plus tard.
job.status()Vérifie le statut du job.
job = service.job(<job_id>)Récupère un job que tu as soumis précédemment. Cet appel nécessite l'identifiant du job.

Récupérer les résultats d'un job ultérieurement​

Appelle service.job(\<job\_id>) pour récupérer un job que tu as soumis précédemment. Si tu n'as pas l'identifiant du job, ou si tu veux récupérer plusieurs jobs à la fois — y compris des jobs provenant de QPUs (unités de traitement quantique) retirées —, appelle plutôt service.jobs() avec des filtres optionnels. Voir QiskitRuntimeService.jobs.

Packages provider dépréciés

service.jobs() retourne également les jobs exécutés depuis le package déprécié qiskit-ibm-provider. Les jobs soumis par l'ancien package (également déprécié) qiskit-ibmq-provider ne sont plus disponibles.

Exemple​

Cet exemple retourne les 10 jobs runtime les plus récents qui ont été exécutés sur my_backend :

# Added by doQumentation — required packages for this notebook
!pip install -q numpy qiskit qiskit-ibm-runtime
# This cell is hidden from users
from qiskit import QuantumCircuit
from qiskit.circuit import Parameter
from qiskit.transpiler import generate_preset_pass_manager

from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2
import numpy as np

my_backend = "ibm_torino"
service = QiskitRuntimeService()
# backend = service.backend(my_backend)
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)

params = np.random.uniform(size=(2, 3)).T

sampler_pub = (transpiled_circuit, params)

# Instantiate the new estimator object, then run the transpiled circuit
# using the set of parameters and observables.
sampler = SamplerV2(mode=backend)
job = sampler.run([sampler_pub], shots=4)
print(job.job_id())
d305ck0ocacs73ajagvg
result = job.result()

spans = job.result().metadata["execution"]["execution_spans"]
print(spans)
ExecutionSpans([DoubleSliceSpan(<start='2025-09-09 16:31:16', stop='2025-09-09 16:31:16', size=24>)])
params = np.random.uniform(size=(2, 3))
params
array([[0.2260416 , 0.8747859 , 0.44361995],
       [0.94700856, 0.96826017, 0.98426562]])
mask = spans[0].mask(0)
mask
array([[[ True,  True,  True,  True],
        [ True,  True,  True,  True]],

       [[ True,  True,  True,  True],
        [ True,  True,  True,  True]],

       [[ True,  True,  True,  True],
        [ True,  True,  True,  True]]])
from qiskit_ibm_runtime import QiskitRuntimeService

# Initialize the account first.
service = QiskitRuntimeService()
# Use `limit` to retrieve a specific number of jobs. The default `limit` is 10.
service.jobs(backend_name=my_backend)

Annuler un job​

Tu peux annuler un job depuis le tableau de bord IBM Quantum Platform, soit sur la page Workloads, soit sur la page de détails d'un workload spécifique. Sur la page Workloads, clique sur le menu de débordement en fin de ligne pour ce workload et sélectionne Annuler. Si tu es sur la page de détails d'un workload spécifique, utilise le menu déroulant Actions en haut de la page et sélectionne Annuler.

Dans Qiskit, utilise job.cancel() pour annuler un job.

Voir les plages d'exécution du Sampler​

Les résultats des jobs SamplerV2 exécutés dans Qiskit Runtime contiennent des informations de timing d'exécution dans leurs métadonnées. Ces informations de timing peuvent être utilisées pour établir des bornes temporelles supérieures et inférieures sur le moment où des shots particuliers ont été exécutés sur le QPU. Les shots sont regroupés dans des objets ExecutionSpan, chacun indiquant une heure de début, une heure de fin et une spécification des shots collectés dans la plage.

Une plage d'exécution spécifie quelles données ont été exécutées durant sa fenêtre en fournissant une méthode ExecutionSpan.mask. Cette méthode, pour tout index de Primitive Unified Block (PUB), retourne un masque booléen qui vaut True pour tous les shots exécutés durant sa fenêtre. Les PUBs sont indexés par l'ordre dans lequel ils ont été transmis à l'appel run du Sampler. Si, par exemple, un PUB a la forme (2, 3) et a été exécuté avec quatre shots, alors la forme du masque est (2, 3, 4). Voir la page API execution_span pour tous les détails.

Exemple : Pour voir les informations sur les plages d'exécution, examine les métadonnées du résultat retourné par SamplerV2, qui se présentent sous la forme d'un objet ExecutionSpans. Cet objet est un conteneur de type liste contenant des instances de sous-classes d'ExecutionSpan, comme SliceSpan :

from qiskit.primitives import BitArray

# Get the mask of the 1st PUB for the 0th span.
mask = spans[0].mask(0)

# Decide whether the 0th shot of parameter set (1, 2) occurred in this span.
in_this_span = mask[2, 1, 0]

# Create a new bit array containing only the PUB-1 data collected during this span.
bits = result[0].data.meas
filtered_data = BitArray(bits.array[mask], bits.num_bits)

Les plages d'exécution peuvent être filtrées pour n'inclure que les informations relatives à des PUBs spécifiques, sélectionnés par leurs indices :

# take the subset of spans that reference data in PUBs 0 or 2
spans.filter_by_pub([0, 2])
ExecutionSpans([DoubleSliceSpan(<start='2025-09-09 16:31:16', stop='2025-09-09 16:31:16', size=24>)])

Consulte les informations globales sur la collection de plages d'exécution :

print("Number of execution spans:", len(spans))
print("  Start of the first span:", spans.start)
print("     End of the last span:", spans.stop)
print("       Total duration (s):", spans.duration)
Number of execution spans: 1
  Start of the first span: 2025-09-09 16:31:16.320568
     End of the last span: 2025-09-09 16:31:16.865858
       Total duration (s): 0.54529

Extrais et inspecte une plage particulière :

spans.sort()
print(" Start of first span:", spans[0].start)
print("   End of first span:", spans[0].stop)
print("#shots in first span:", spans[0].size)
Start of first span: 2025-09-09 16:31:16.320568
   End of first span: 2025-09-09 16:31:16.865858
#shots in first span: 24
remarque

Il est possible que les fenêtres temporelles spécifiées par des plages d'exécution distinctes se chevauchent. Cela n'est pas dû au fait qu'un QPU effectuait plusieurs exécutions simultanément, mais est plutôt un artefact de certains traitements classiques pouvant se produire en parallèle de l'exécution quantique. La garantie offerte est que les données référencées se sont définitivement produites dans la plage d'exécution indiquée, mais pas nécessairement que les limites de la fenêtre temporelle sont aussi précises que possible.

Prochaines étapes​

Recommandations