Monitorare o annullare un lavoro

Questa guida spiega come monitorare lo stato dei lavori, visualizzare le informazioni sull'utilizzo e annullare i lavori. È possibile accedere a queste informazioni sia tramite IBM Quantum® Platform sia a livello di programmazione utilizzando Qiskit.

• Versioni del pacchetto

  Il codice presente in questa pagina è stato sviluppato sulla base dei seguenti requisiti. Si consiglia di utilizzare queste versioni o quelle più recenti.

  qiskit-ibm-runtime~=0.46.1
  

Monitorare un lavoro

Utilizza questi metodi per verificare lo stato dei lavori inviati, recuperare i risultati e visualizzare i dettagli relativi al lavoro e alla sua esecuzione.

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)

Perché un'attività rimane "In corso"

Potresti notare che un’operazione (sia in modalità job che in modalità batch) che ti aspetti duri solo pochi secondi rimane nello stato “In corso ” (denominato RUNNING in Qiskit) per molto più tempo. È normale, e non significa che l'attività stia occupando tutto quel tempo in termini di utilizzo. Ciò accade a causa del modo in cui i processi vengono pianificati su una QPU:

• Ogni processo richiede una fase di pre-elaborazione standard prima di poter essere eseguito sulla QPU. Un lavoro passa allo stato “In corso ” (RUNNING) non appena ha inizio questa elaborazione classica — non quando inizia l’esecuzione sulla QPU.
• La maggior parte di queste operazioni di elaborazione classica viene eseguita in parallelo, quindi è possibile che più processi siano in corso contemporaneamente.
• Tuttavia, sulla QPU può essere eseguito un solo processo alla volta. Quando diversi processi hanno completato l'elaborazione classica e sono pronti per essere eseguiti, devono attendere il proprio turno per accedere alla QPU. Questo fenomeno è noto come contesa QPU. Quando il livello di contesa è elevato, un processo può rimanere in corso per un tempo notevolmente più lungo rispetto ai pochi secondi di tempo QPU di cui ha effettivamente bisogno.
• Possono verificarsi situazioni di contesa anche quando sulla QPU è in esecuzione un’attività di manutenzione del sistema, come ad esempio la calibrazione. Il tuo lavoro rimane " In corso" fino al completamento dell'attività di manutenzione e alla disponibilità della QPU.

Per questo motivo, il tempo effettivo trascorso da un processo nello stato “In corso” non corrisponde al suo tempo di utilizzo. Sia la stima dei tempi di utilizzo che il tempo massimo di esecuzione si basano esclusivamente sul tempo in cui la QPU è riservata all'esecuzione del tuo lavoro e, pertanto, escludono l'elaborazione classica multithread descritta sopra. Un tempo di elaborazione prolungato non comporta un aumento dell'utilizzo o dei costi riportati.

La modalità di sessione è diversa

Il comportamento descritto in precedenza si applica sia alla modalità "job" che alla modalità "batch". In modalità sessione, mentre la finestra della sessione è attiva, l'utente ha accesso esclusivo al backend e nessun altro processo può essere eseguito, compresi i processi di calibrazione. Pertanto, eventuali conflitti relativi alla QPU si verificano solo tra i processi della propria sessione. Inoltre, poiché la capacità della QPU viene riservata per tutta la durata della sessione, l'utilizzo della sessione viene misurato in base al tempo trascorso mentre la sessione rimane attiva, indipendentemente dal fatto che i processi siano effettivamente in esecuzione. Per ulteriori informazioni, consultare la sezione " Utilizzo del carico di lavoro".

Visualizza utilizzo residuo

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

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

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

Visualizza le metriche relative alle offerte di lavoro

Ottieni una panoramica delle tue richieste di elaborazione, comprese le metriche relative al carico di lavoro per batch e per sessione.

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 del lavoro in un secondo momento

È possibile salvare gli ID dei lavori e recuperare i risultati in un secondo momento, anche dopo aver chiuso la sessione.

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

Recupera le proprietà 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")

Annulla un lavoro

Annulla un processo in coda o in esecuzione. Una volta annullato, un lavoro non può essere ripreso.

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