Surveiller ou annuler une tâche

Ce guide explique comment suivre l'état des tâches, consulter les informations d'utilisation et annuler des tâches. Vous pouvez accéder à ces informations soit via IBM Quantum® Platform, soit par programmation à l'aide de Qiskit.

• Versions de package

  Le code présenté sur cette page a été développé en respectant les exigences suivantes. Nous vous recommandons d'utiliser ces versions ou des versions plus récentes.

  qiskit-ibm-runtime~=0.46.1
  

Surveiller une tâche

Utilisez ces méthodes pour vérifier l'état des tâches que vous avez soumises, récupérer les résultats et consulter les détails relatifs à la tâche et à son exécution.

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)

Pourquoi une tâche reste-t-elle « En cours »?

Vous remarquerez peut-être qu'une tâche (en mode « job » ou en mode « batch ») qui, selon vos prévisions, ne devrait prendre que quelques secondes, reste dans l'état «** En cours** » (appelé RUNNING dans Qiskit) pendant bien plus longtemps. C'est normal, et cela ne signifie pas que la tâche occupe tout ce temps en termes d'utilisation. Cela s'explique par la manière dont les tâches sont planifiées sur une QPU :

• Chaque tâche nécessite un prétraitement classique avant de pouvoir être exécutée sur le QPU. Une tâche passe à l'état « En cours » (RUNNING) dès que ce traitement classique commence — et non pas lorsqu'elle commence à s'exécuter sur le QPU.
• La plupart de ces traitements classiques s'exécutent en parallèle, ce qui permet de mener plusieurs tâches de front.
• Cependant, un seul travail à la fois peut s'exécuter sur le QPU. Lorsque plusieurs tâches ont terminé leur traitement classique et sont prêtes à être exécutées, elles doivent attendre leur tour pour accéder au QPU. C'est ce qu'on appelle un conflit de QPU. Lorsque la contention est élevée, une tâche peut rester « En cours » nettement plus longtemps que les quelques secondes de temps QPU dont elle a réellement besoin.
• Des conflits peuvent également survenir lorsqu'une tâche de maintenance du système, telle qu'un étalonnage, est en cours d'exécution sur le QPU. Votre tâche reste en cours jusqu'à ce que la tâche de maintenance soit terminée et que le QPU soit à nouveau disponible.

C'est pourquoi la durée réelle (en temps réel) pendant laquelle une tâche est en cours d'exécution ne correspond pas à son temps d'utilisation. Tant l' estimation de la durée d'utilisation que la durée d'exécution maximale sont calculées uniquement en fonction du temps pendant lequel le QPU est réservé à l'exécution de votre tâche; elles n'incluent donc pas le traitement classique multithread décrit ci-dessus. Une durée prolongée de l'état « En cours » n'entraîne pas d'augmentation de votre consommation déclarée ni de vos coûts.

Le mode « session » est différent

Le comportement décrit ci-dessus s'applique aussi bien au mode « job » qu'au mode « batch ». En mode session, tant que la fenêtre de session est active, l'utilisateur dispose d'un accès exclusif au backend et aucune autre tâche ne peut s'exécuter, y compris les tâches d'étalonnage. Par conséquent, tout conflit d'accès à la QPU ne se produit qu'entre les tâches de votre propre session. De plus, la capacité de la QPU étant réservée pour toute la durée de la session, l'utilisation de la session est mesurée en fonction du temps écoulé tant que la session reste active, que les tâches soient en cours d'exécution ou non. Pour plus d'informations, consultez la section « Utilisation de la charge de travail ».

Afficher l'utilisation restante

Suivez le solde de votre quota d'utilisation.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

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

Afficher les indicateurs de performance de l'offre d'emploi

Obtenez une vue d'ensemble de vos soumissions de tâches, y compris les indicateurs de charge de travail par lot et par session.

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 travail ultérieurement

Vous pouvez enregistrer les identifiants de tâche et consulter les résultats ultérieurement, même après avoir fermé votre session.

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

Récupérer les propriétés du backend

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 travail

Annuler une tâche en attente ou en cours d'exécution. Une fois qu'une tâche a été annulée, elle ne peut plus être reprise.

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

Etapes suivantes