Surveiller ou annuler un job

Ce guide explique comment surveiller le statut d'un job, consulter les informations d'utilisation et annuler des jobs. Tu peux accéder à ces informations à la fois via IBM Quantum® Platform et par programmation avec Qiskit.

Versions des packages

Le code de cette page a été développé à l'aide des exigences suivantes. Nous recommandons d'utiliser ces versions ou des versions plus récentes.

qiskit-ibm-runtime~=0.46.1

Surveiller un job

Utilise ces méthodes pour vérifier le statut de tes jobs soumis, récupérer les résultats et consulter les détails relatifs au job et à son exécution.

Surveiller un job avec Qiskit
Surveiller un job sur IBM Quantum Platform

L'instance du job propose plusieurs méthodes de surveillance :

Méthode	Description
`job.status()`	Vérifier l'état actuel du job
`job.job_id()`	Obtenir l'identifiant unique du job
`job.result()`	Récupérer les résultats du job (appel bloquant jusqu'à la fin)
`job.wait_for_final_state()`	Bloquer jusqu'à ce que le job atteigne un état terminal

Pourquoi un job reste "In progress"

Tu remarqueras peut-être qu'un job (utilisant le job mode ou le batch mode) que tu attends de voir se terminer en quelques secondes reste dans le statut In progress (appelé RUNNING dans Qiskit) beaucoup plus longtemps. C'est normal, et cela ne signifie pas que le job consomme tout ce temps en tant qu'utilisation. Cela s'explique par la façon dont les jobs sont planifiés sur un QPU :

Chaque job nécessite un pré-traitement classique avant de pouvoir s'exécuter sur le QPU. Un job passe à In progress (RUNNING) dès que ce traitement classique commence — et non lorsqu'il commence à s'exécuter sur le QPU.
La majeure partie de ce traitement classique s'exécute en parallèle, de sorte que plusieurs jobs peuvent être In progress en même temps.
Cependant, un seul job à la fois peut s'exécuter sur le QPU. Lorsque plusieurs jobs terminent leur traitement classique et sont prêts à s'exécuter, ils doivent attendre leur tour pour le QPU. C'est ce qu'on appelle la contention du QPU. Lorsque la contention est élevée, un job peut rester In progress nettement plus longtemps que les quelques secondes de temps QPU dont il a réellement besoin.
Une contention peut également survenir lorsqu'une tâche de maintenance système, telle qu'une calibration, est en cours sur le QPU. Ton job reste In progress jusqu'à ce que la tâche de maintenance se termine et que le QPU redevienne disponible.

De ce fait, le temps réel écoulé qu'un job passe en In progress n'est pas identique à son utilisation. Aussi bien l'utilisation estimée que le temps d'exécution maximum sont basés uniquement sur le temps pendant lequel le QPU est réservé à l'exécution de ton job, et excluent donc le traitement classique multi-threadé décrit ci-dessus. Un temps In progress long n'augmente pas ton utilisation ou ton coût déclarés.

Le session mode est différent

Le comportement précédent s'applique au job mode et au batch mode. En session mode, pendant la fenêtre active de la session, l'utilisateur dispose d'un accès exclusif au backend et aucun autre job ne peut s'exécuter, y compris les jobs de calibration. Par conséquent, toute contention du QPU ne se produit qu'entre tes propres jobs de session. De plus, comme la capacité du QPU est réservée pour la durée de la session, l'utilisation de la session est mesurée comme le temps écoulé pendant que la session reste active, que des jobs soient effectivement en cours d'exécution ou non. Consulte Utilisation des workloads pour plus d'informations.

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"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

service = QiskitRuntimeService()

# Retrieve a job by ID
job = service.job("<job_id>")

# Get job ID (useful for saving for later retrieval)
print(f"Job ID: {job.job_id()}")

# Check current status
print(f"Status: {job.status()}")

# Wait for job to complete (blocking call)
job.wait_for_final_state()
print("Job completed")

# Get results
results = job.result()
print(results)

Voir l'utilisation restante

Suis la part restante du quota d'utilisation de ton plan.

Vérifier l'utilisation avec Qiskit
Consulter l'utilisation sur IBM Quantum Platform

Utilise la méthode service.usage() pour obtenir les informations d'utilisation de ton instance active actuelle.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

# Get usage information for the current active instance
usage = service.usage()
print(usage)

Voir les métriques d'un job

Obtiens un aperçu de tes soumissions de jobs, y compris les métriques des workloads batch et session.

Obtenir les métriques d'un job avec Qiskit
Voir les métriques d'un job sur IBM Quantum Platform

Utilise la méthode service.jobs() avec des filtres pour récupérer des informations sur tes jobs soumis, telles que le nombre de jobs soumis, leurs statuts, et leur date de création. L'exemple suivant récupère tous les jobs soumis au cours des sept derniers jours et calcule l'utilisation totale de ces jobs.

from datetime import datetime, timedelta
from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

# Retrieve all jobs in the last 7 days
seven_days_ago = datetime.now() - timedelta(days=7)
jobs = service.jobs(limit=None, created_after=seven_days_ago)

# To retrieve all jobs in a Session or Batch, use the session_id filter
# jobs = service.jobs(session_id="<session id>")

total_usage = 0
for job in jobs:
    total_usage += job.usage()

print(f"{len(jobs)} jobs were submitted in the last 7 days.")
print(f"Total usage was {total_usage} seconds")

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

Tu peux enregistrer les identifiants de job et récupérer les résultats plus tard, même après avoir fermé ta session.

Récupérer les résultats avec Qiskit
Récupérer les résultats sur IBM Quantum Platform

Si tu as enregistré l'ID du job lors de sa soumission, utilise service.job(<job_id>) pour le récupérer plus tard. Si tu n'as pas l'ID du job, ou si tu veux récupérer plusieurs jobs à la fois (y compris les jobs des QPU retirés), utilise plutôt service.jobs(), avec des filtres facultatifs.

Consulte la documentation de l'API QiskitRuntimeService.jobs pour connaître les filtres disponibles.

Cet exemple montre comment récupérer les résultats récents exécutés sur un backend spécifique.

Récupérer les propriétés d'un backend

Récupérer les propriétés d'un backend avec Qiskit
Récupérer les propriétés d'un backend sur IBM Quantum Platform

Tu peux utiliser job.properties() pour récupérer les propriétés d'un backend, y compris les taux d'erreur, au moment de l'exécution du job.

Cet exemple montre comment récupérer les propriétés d'un backend qui étaient valides au moment où un job a été exécuté, y compris les temps $T_1$ / $T_2$ et les taux d'erreur pour un qubit spécifique (0).

Packages de fournisseur obsolètes

service.jobs() renvoie également les jobs exécutés à partir du package obsolète qiskit-ibm-provider. Les jobs soumis par l'ancien package (également obsolète) qiskit-ibmq-provider ne sont plus disponibles.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

# Uncomment the next line to retrieve a specific job by ID
# job = service.job("<job_id>")

# Optionally retrieve multiple jobs with filters
# Use `limit` to retrieve a specific number of jobs. The default `limit` is 10.
my_backend = "<your-backend>"
recent_jobs = service.jobs(backend_name=my_backend, limit=10)

print(f"Retrieved {len(recent_jobs)} recent jobs from {my_backend}\n")

# Get results from all jobs
for job in recent_jobs:
    print(f"Job ID: {job.job_id()}")
    print(f"Status: {job.status()}")

    # Retrieve results if the job is complete
    if str(job.status()) == "DONE":
        try:
            results = job.result()
            print(f"Results: {results}")
        except Exception as e:
            print(f"Error retrieving results: {e}")
    else:
        print("Results: Not available (job still running or failed)")
    print()

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

# Retrieve a specific job by ID
job = service.job("<job_id>")

print(f"Job ID: {job.job_id()}")
print(f"Backend: {job.backend}\n")

# Fetch backend properties at the time of job execution
properties = job.properties()

if properties:
    print("Backend Properties at Job Execution Time:")
    print("=" * 60)

    # Get T1 (relaxation time) for qubit 0
    t1 = properties.t1(0)
    print(f"Qubit 0 T1 (relaxation time): {t1}")

    # Get T2 (dephasing time) for qubit 0
    t2 = properties.t2(0)
    print(f"Qubit 0 T2 (dephasing time): {t2}")

    # Get readout error for qubit 0
    readout_error = properties.readout_error(0)
    print(f"Qubit 0 readout error: {readout_error}")

    # Get all properties for a specific qubit
    print("All properties for qubit 0:")
    qubit_props = properties.qubit_property(0)
    for prop_name, prop_value in qubit_props.items():
        print(f"  {prop_name}: {prop_value}")
else:
    print("No properties available for this job")

Annuler un job

Annule un job qui est en file d'attente ou en cours d'exécution. Une fois qu'un job est annulé, il ne peut pas être repris.

Annuler avec Qiskit
Annuler sur IBM Quantum Platform

Utilise la méthode job.cancel() pour annuler un job par programmation.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

# Retrieve the job
job = service.job("<job_id>")

# Cancel the job
job.cancel()

print(f"Job {job.job_id()} has been canceled")

Prochaines étapes

Recommandations

Consulte la référence de l'API QiskitRuntimeService pour d'autres méthodes de gestion des jobs.
Explore les modes d'exécution pour comprendre les types de workloads batch et session.

Surveiller un job​

Pourquoi un job reste "In progress"​

Le session mode est différent​

Voir l'utilisation restante​

Voir les métriques d'un job​

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

Récupérer les propriétés d'un backend​

Annuler un job​

Prochaines étapes​