Monitorear o cancelar un job

Esta guía explica cómo monitorear el estado de un job, ver información de uso y cancelar jobs. Puedes acceder a esta información tanto a través de IBM Quantum® Platform como programáticamente usando Qiskit.

Versiones de los paquetes

El código de esta página se desarrolló usando los siguientes requisitos. Recomendamos usar estas versiones o más recientes.

qiskit-ibm-runtime~=0.46.1

Monitorear un job

Usa estos métodos para verificar el estado de tus jobs enviados, recuperar resultados y ver detalles relacionados con el job y su ejecución.

Monitor a job with Qiskit
Monitor a job on IBM Quantum Platform

La instancia de job proporciona varios métodos para monitorear:

Método	Descripción
`job.status()`	Consulta el estado actual del job
`job.job_id()`	Obtén el identificador único del job
`job.result()`	Recupera los resultados del job (llamada bloqueante hasta que se complete)
`job.wait_for_final_state()`	Bloquea hasta que el job alcance un estado terminal

Por qué un job permanece "In progress"

Es posible que notes que un job (usando ya sea job mode o batch mode) que esperas que tarde solo unos segundos permanece en el estado In progress (llamado RUNNING en Qiskit) durante mucho más tiempo. Esto es normal, y no significa que el job esté consumiendo todo ese tiempo como uso. Ocurre debido a la forma en que los jobs se programan en una QPU:

Cada job requiere un preprocesamiento clásico antes de poder ejecutarse en la QPU. Un job pasa a In progress (RUNNING) tan pronto como comienza este procesamiento clásico, no cuando empieza a ejecutarse en la QPU.
La mayor parte de este procesamiento clásico se ejecuta en paralelo, por lo que varios jobs pueden estar In progress al mismo tiempo.
Sin embargo, solo un job a la vez puede ejecutarse en la QPU. Cuando varios jobs terminan su procesamiento clásico y están listos para ejecutarse, deben esperar su turno para la QPU. Esto se conoce como contención de QPU. Cuando la contención es alta, un job puede permanecer In progress notablemente más tiempo que los pocos segundos de tiempo de QPU que realmente necesita.
La contención también puede ocurrir cuando una tarea de mantenimiento del sistema, como la calibración, se está ejecutando en la QPU. Tu job permanece In progress hasta que la tarea de mantenimiento se completa y la QPU queda disponible.

Debido a esto, el tiempo transcurrido en reloj real que un job pasa In progress no es lo mismo que su uso. Tanto el uso estimado como el tiempo máximo de ejecución se basan únicamente en el tiempo en que la QPU está bloqueada para ejecutar tu job, y por lo tanto excluyen el procesamiento clásico multihilo descrito anteriormente. Un tiempo largo en In progress no aumenta tu uso reportado ni el costo.

Session mode es diferente

El comportamiento anterior se aplica a job mode y a batch mode. En session mode, durante la ventana activa de la sesión, el usuario tiene acceso exclusivo al backend y ningún otro job puede ejecutarse, incluidos los jobs de calibración. Por lo tanto, cualquier contención de QPU ocurre solo entre los jobs de tu propia sesión. Además, dado que la capacidad de la QPU está reservada durante la duración de la sesión, el uso de la sesión se mide como el tiempo transcurrido mientras la sesión permanece activa, independientemente de si los jobs se están ejecutando activamente. Consulta Uso de la carga de trabajo para más información.

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

Ver el uso restante

Rastrea cuánto queda de la cuota de uso de tu plan.

Check usage with Qiskit
View usage on IBM Quantum Platform

Usa el método service.usage() para obtener información de uso de tu instancia activa actual.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

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

Ver métricas de jobs

Obtén una visión general de tus envíos de jobs, incluidas las métricas de las cargas de trabajo de batch y sesión.

Get job metrics with Qiskit
View job metrics on IBM Quantum Platform

Usa el método service.jobs() con filtros para recuperar información sobre tus jobs enviados, como cuántos se han enviado, cuáles son sus estados y cuándo se crearon. El siguiente ejemplo recupera todos los jobs enviados en los últimos siete días y calcula el uso total de esos 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")

Recuperar resultados de un job en un momento posterior

Puedes guardar los IDs de los jobs y recuperar los resultados más tarde, incluso después de cerrar tu sesión.

Retrieve results with Qiskit
Retrieve results on IBM Quantum Platform

Si guardaste el ID del job cuando lo enviaste, usa service.job(<job_id>) para recuperarlo más tarde. Si no tienes el ID del job, o si quieres recuperar varios jobs a la vez (incluidos jobs de QPUs retiradas), usa service.jobs() en su lugar, con filtros opcionales.

Consulta la documentación de la API de QiskitRuntimeService.jobs para ver los filtros disponibles.

Este ejemplo demuestra cómo recuperar resultados recientes ejecutados en un backend específico.

Recupera propiedades del backend

Retrieve backend properties with Qiskit
Retrieve backend properties on IBM Quantum Platform

Puedes usar job.properties() para recuperar propiedades del backend, incluidas las tasas de error, en el momento de la ejecución del job.

Este ejemplo demuestra cómo recuperar propiedades del backend que estaban vigentes en el momento en que se ejecutó un job, incluyendo los tiempos $T_1$ / $T_2$ y las tasas de error para un qubit específico (0).

Paquetes de proveedor obsoletos

service.jobs() también devuelve jobs ejecutados desde el paquete obsoleto qiskit-ibm-provider. Los jobs enviados por el paquete más antiguo (también obsoleto) qiskit-ibmq-provider ya no están 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")

Cancelar un job

Cancela un job que está en cola o en ejecución. Una vez que un job se cancela, no se puede reanudar.

Cancel with Qiskit
Cancel on IBM Quantum Platform

Usa el método job.cancel() para cancelar un job programáticamente.

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

Próximos pasos

Recomendaciones

Revisa la referencia de API de QiskitRuntimeService para métodos adicionales de gestión de jobs.
Explora los modos de ejecución para entender los tipos de carga de trabajo batch y sesión.

Monitorear un job​

Por qué un job permanece "In progress"​

Session mode es diferente​

Ver el uso restante​

Ver métricas de jobs​

Recuperar resultados de un job en un momento posterior​

Recupera propiedades del backend​

Cancelar un job​

Próximos pasos​