Monitorare o annullare un job

Questa guida spiega come monitorare lo stato di un job, visualizzare le informazioni sull'utilizzo e annullare i job. Puoi accedere a queste informazioni sia tramite IBM Quantum® Platform sia programmaticamente usando Qiskit.

Versioni dei pacchetti

Il codice in questa pagina è stato sviluppato utilizzando i seguenti requisiti. Consigliamo di utilizzare queste versioni o versioni più recenti.

qiskit-ibm-runtime~=0.46.1

Monitorare un job

Usa questi metodi per controllare lo stato dei job inviati, recuperare i risultati e visualizzare i dettagli relativi al job e alla sua esecuzione.

Monitora un job con Qiskit
Monitora un job su IBM Quantum Platform

L'istanza del job fornisce diversi metodi per il monitoraggio:

Method	Description
`job.status()`	Check the current job status
`job.job_id()`	Get the unique job identifier
`job.result()`	Retrieve job results (blocking call until complete)
`job.wait_for_final_state()`	Block until the job reaches a terminal state

Perché un job rimane "In progress"

Potresti notare che un job (in job mode o in batch mode) che ti aspetti richieda solo pochi secondi rimane nello stato In progress (chiamato RUNNING in Qiskit) molto più a lungo. Questo è normale e non significa che il job stia consumando l'intero tempo come utilizzo. Accade a causa di come i job vengono pianificati su una QPU:

Ogni job richiede un pre-processing classico prima di poter essere eseguito sulla QPU. Un job passa a In progress (RUNNING) non appena inizia questo processing classico — non quando inizia l'esecuzione sulla QPU.
La maggior parte di questo processing classico viene eseguita in parallelo, quindi più job possono essere In progress contemporaneamente.
Tuttavia, solo un job alla volta può essere eseguito sulla QPU. Quando diversi job terminano il loro processing classico e sono pronti per l'esecuzione, devono aspettare il proprio turno per la QPU. Questo è noto come contesa della QPU. Quando la contesa è alta, un job può rimanere In progress notevolmente più a lungo rispetto ai pochi secondi di tempo QPU di cui ha effettivamente bisogno.
La contesa può verificarsi anche quando un'attività di manutenzione del sistema, come la calibrazione, è in esecuzione sulla QPU. Il tuo job rimane In progress finché l'attività di manutenzione non si completa e la QPU diventa disponibile.

Per questo motivo, il tempo reale trascorso da un job nello stato In progress non è lo stesso del suo utilizzo. Sia l'utilizzo stimato sia il tempo massimo di esecuzione sono basati solo sul tempo in cui la QPU è bloccata per eseguire il tuo job, e quindi escludono il processing classico multi-thread descritto sopra. Un lungo tempo In progress non aumenta il tuo utilizzo o costo riportato.

La session mode è diversa

Il comportamento precedente si applica a job mode e a batch mode. In session mode, durante la finestra attiva della sessione, l'utente ha accesso esclusivo al backend e nessun altro job può essere eseguito, inclusi i job di calibrazione. Pertanto, qualsiasi contesa della QPU avviene solo tra i job della tua stessa sessione. Inoltre, poiché la capacità della QPU è riservata per la durata della sessione, l'utilizzo della sessione viene misurato come il tempo trascorso mentre la sessione rimane attiva, indipendentemente dal fatto che i job siano effettivamente in esecuzione. Consulta Utilizzo del workload per maggiori informazioni.

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

Visualizzare l'utilizzo residuo

Tieni traccia di quanto rimane della quota di utilizzo del tuo piano.

Controlla l'utilizzo con Qiskit
Visualizza l'utilizzo su IBM Quantum Platform

Usa il metodo service.usage() per ottenere le informazioni sull'utilizzo per la tua istanza attiva corrente.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

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

Visualizzare le metriche dei job

Ottieni una panoramica degli invii dei tuoi job, incluse le metriche dei workload batch e sessione.

Ottieni le metriche dei job con Qiskit
Visualizza le metriche dei job su IBM Quantum Platform

Usa il metodo service.jobs() con filtri per recuperare informazioni sui job inviati, come quanti ne sono stati inviati, quali sono i loro stati e quando sono stati creati. L'esempio seguente recupera tutti i job inviati negli ultimi sette giorni e calcola l'utilizzo totale di quei job.

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

Recuperare i risultati di un job in un secondo momento

Puoi salvare gli ID dei job e recuperare i risultati in seguito, anche dopo aver chiuso la tua sessione.

Recupera i risultati con Qiskit
Recupera i risultati su IBM Quantum Platform

Se hai salvato l'ID del job quando lo hai inviato, usa service.job(<job_id>) per recuperarlo in seguito. Se non hai l'ID del job, o se vuoi recuperare più job contemporaneamente (inclusi i job da QPU ritirate), usa invece service.jobs(), con filtri opzionali.

Consulta la documentazione API QiskitRuntimeService.jobs per i filtri disponibili.

Questo esempio mostra come recuperare i risultati recenti eseguiti su un backend specifico.

Recuperare le proprietà del backend

Recupera le proprietà del backend con Qiskit
Recupera le proprietà del backend su IBM Quantum Platform

Puoi usare job.properties() per recuperare le proprietà del backend, inclusi i tassi di errore, al momento dell'esecuzione del job.

Questo esempio mostra come recuperare le proprietà del backend valide al momento in cui un job è stato eseguito, inclusi i tempi $T_1$ / $T_2$ e i tassi di errore per un qubit specifico (0).

Pacchetti provider deprecati

service.jobs() restituisce anche i job eseguiti dal pacchetto deprecato qiskit-ibm-provider. I job inviati dal pacchetto più vecchio (anch'esso deprecato) qiskit-ibmq-provider non sono più disponibili.

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

Annullare un job

Annulla un job che è in coda o in esecuzione. Una volta annullato un job, non può essere ripreso.

Annulla con Qiskit
Annulla su IBM Quantum Platform

Usa il metodo job.cancel() per annullare un job programmaticamente.

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

Passi successivi

Raccomandazioni

Consulta il riferimento API QiskitRuntimeService per ulteriori metodi di gestione dei job.
Esplora le modalità di esecuzione per comprendere i tipi di workload batch e sessione.

Monitorare un job​

Perché un job rimane "In progress"​

La session mode è diversa​

Visualizzare l'utilizzo residuo​

Visualizzare le metriche dei job​

Recuperare i risultati di un job in un secondo momento​

Recuperare le proprietà del backend​

Annullare un job​

Passi successivi​