Supervisar o cancelar un trabajo

En esta guía se explica cómo supervisar el estado de los trabajos, consultar la información de uso y cancelar trabajos. Puedes acceder a esta información tanto a través de IBM Quantum® Platform como mediante programación con Qiskit.

• Versiones del paquete

  El código de esta página se ha desarrollado teniendo en cuenta los siguientes requisitos. Recomendamos utilizar estas versiones o posteriores.

  qiskit-ibm-runtime~=0.46.1
  

Supervisar un trabajo

Utiliza estos métodos para comprobar el estado de los trabajos que has enviado, recuperar los resultados y consultar los detalles relacionados con el trabajo y su ejecución.

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)

¿Por qué un trabajo permanece «En curso»?

Es posible que observes que un trabajo (ya sea en modo «job» o en modo «batch») que esperabas que durara solo unos segundos permanece en el estado «En curso» (denominado en RUNNING Qiskit) durante mucho más tiempo. Esto es normal y no significa que el trabajo esté consumiendo todo ese tiempo en uso. Esto ocurre debido a la forma en que se programan los trabajos en una QPU:

• Cada tarea requiere un preprocesamiento clásico antes de poder ejecutarse en la QPU. Un trabajo pasa al estado «En curso » (RUNNING) en cuanto comienza este procesamiento clásico, y no cuando empieza a ejecutarse en la QPU.
• La mayor parte de este procesamiento clásico se ejecuta en paralelo, por lo que pueden estar en curso varios trabajos al mismo tiempo.
• Sin embargo, en la QPU solo puede ejecutarse un trabajo a la vez. Cuando varios trabajos han finalizado su procesamiento clásico y están listos para ejecutarse, deben esperar su turno para acceder a la QPU. Esto se conoce como «contienda de la QPU ». Cuando el nivel de contención es elevado, un trabajo puede permanecer «En curso» durante un tiempo notablemente superior a los pocos segundos de tiempo de QPU que realmente necesita.
• También pueden producirse conflictos cuando se está ejecutando en la QPU una tarea de mantenimiento del sistema, como una calibración. Tu trabajo permanecerá «En curso» hasta que finalice la tarea de mantenimiento y la QPU vuelva a estar disponible.

Por este motivo, el tiempo real transcurrido durante el que un trabajo permanece «en curso» no coincide con su tiempo de uso. Tanto el tiempo de uso estimado como el tiempo máximo de ejecución se basan únicamente en el tiempo durante el que la QPU queda reservada para ejecutar tu trabajo y, por lo tanto, no incluyen el procesamiento clásico multihilo descrito anteriormente. Un tiempo prolongado en «En curso» no aumenta el consumo ni el coste que se te facturan.

El modo de sesión es diferente

El comportamiento descrito anteriormente se aplica tanto al modo de trabajo como al modo por lotes. En el modo de sesión, mientras la ventana de la sesión esté activa, el usuario tiene acceso exclusivo al backend y no se puede ejecutar ningún otro trabajo, incluidos los de calibración. Por lo tanto, cualquier conflicto en la QPU solo se produce entre los trabajos de tu propia sesión. Además, dado que la capacidad de la QPU queda reservada mientras dura 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 trabajos se están ejecutando en ese momento. Consulta «Uso de la carga de trabajo» para obtener más información.

Ver uso restante

Controla cuánto te queda de la cuota de uso de tu plan.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

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

Ver métricas del trabajo

Obtén una visión general de los trabajos enviados, incluidas las métricas de carga de trabajo por lotes y sesiones.

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 los resultados del trabajo más tarde

Puedes guardar los ID de los trabajos y recuperar los resultados más tarde, incluso después de cerrar la sesión.

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

Recuperar las propiedades del 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")

Cancele un trabajo

Cancelar un trabajo que esté en cola o en ejecución. Una vez cancelado un trabajo, no se puede reanudar.

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