Monitorizează sau anulează un job

Acest ghid explică cum să monitorizezi starea unui job, să vizualizezi informații despre utilizare și să anulezi job-uri. Poți accesa aceste informații atât prin IBM Quantum® Platform, cât și programatic folosind Qiskit.

Versiuni de pachete

Codul de pe această pagină a fost dezvoltat folosind următoarele cerințe. Recomandăm folosirea acestor versiuni sau a unora mai noi.

qiskit-ibm-runtime~=0.46.1

Monitorizează un job

Folosește aceste metode pentru a verifica starea job-urilor trimise, a prelua rezultate și a vizualiza detalii legate de job și de execuția acestuia.

Monitorizează un job cu Qiskit
Monitorizează un job pe IBM Quantum Platform

Instanța job-ului oferă mai multe metode pentru monitorizare:

Metodă	Descriere
`job.status()`	Verifică starea curentă a jobului
`job.job_id()`	Obține identificatorul unic al jobului
`job.result()`	Preia rezultatele jobului (apel blocant până la finalizare)
`job.wait_for_final_state()`	Blochează până când jobul atinge o stare finală

De ce un job rămâne "In progress"

Poți observa că un job (folosind fie modul job, fie modul batch) pe care te aștepți să dureze doar câteva secunde rămâne în starea In progress (numit RUNNING în Qiskit) mult mai mult timp. Acest lucru este normal și nu înseamnă că job-ul consumă tot acel timp ca utilizare. Se întâmplă din cauza modului în care job-urile sunt programate pe un QPU:

Fiecare job necesită preprocesare clasică înainte de a putea rula pe QPU. Un job trece la In progress (RUNNING) imediat ce începe această procesare clasică — nu când începe să se execute pe QPU.
Cea mai mare parte a acestei procesări clasice rulează în paralel, astfel încât mai multe job-uri pot fi In progress în același timp.
Totuși, doar un singur job poate rula pe QPU la un moment dat. Când mai multe job-uri își finalizează procesarea clasică și sunt gata de execuție, trebuie să își aștepte rândul pentru QPU. Acest lucru este cunoscut ca contenție QPU. Când contenția este ridicată, un job poate rămâne In progress semnificativ mai mult timp decât cele câteva secunde de timp QPU de care are efectiv nevoie.
Contenția poate apărea și atunci când o sarcină de întreținere a sistemului, cum ar fi calibrarea, rulează pe QPU. Job-ul tău rămâne In progress până când sarcina de întreținere se finalizează și QPU devine disponibil.

Din această cauză, timpul real scurs pe care un job îl petrece In progress nu este același lucru cu utilizarea sa. Atât utilizarea estimată, cât și timpul maxim de execuție se bazează doar pe timpul în care QPU este blocat pentru a executa job-ul tău și, prin urmare, exclud procesarea clasică multi-threaded descrisă mai sus. Un timp îndelungat In progress nu îți crește utilizarea sau costul raportat.

Modul session este diferit

Comportamentul anterior se aplică modului job și modului batch. În modul session, în timpul ferestrei active a session-ului, utilizatorul are acces exclusiv la backend și niciun alt job nu poate rula, inclusiv job-uri de calibrare. Prin urmare, orice contenție QPU are loc doar între propriile tale job-uri de session. În plus, deoarece capacitatea QPU este rezervată pe durata session-ului, utilizarea session-ului este măsurată ca timpul scurs cât timp session-ul rămâne activ, indiferent dacă job-urile rulează efectiv sau nu. Consultă Utilizarea sarcinilor de lucru pentru mai multe informații.

# Added by doQumentation — required packages for this notebook
!pip install -q qiskit-ibm-runtime

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)

Vizualizează utilizarea rămasă

Urmărește cât din cota de utilizare a planului tău mai rămâne.

Verifică utilizarea cu Qiskit
Vizualizează utilizarea pe IBM Quantum Platform

Folosește metoda service.usage() pentru a obține informații despre utilizare pentru instanța ta activă curentă.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

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

Vizualizează metricile job-urilor

Obține o prezentare generală a trimiterilor tale de job-uri, inclusiv metrici pentru sarcinile de lucru de tip batch și session.

Obține metricile job-urilor cu Qiskit
Vizualizează metricile job-urilor pe IBM Quantum Platform

Folosește metoda service.jobs() cu filtre pentru a prelua informații despre job-urile trimise de tine, cum ar fi câte au fost trimise, care sunt stările lor și când au fost create. Exemplul următor preia toate job-urile trimise în ultimele șapte zile și calculează utilizarea totală din acele job-uri.

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

Recuperează rezultatele unui job la o dată ulterioară

Poți salva ID-urile job-urilor și prelua rezultatele mai târziu, chiar și după închiderea session-ului tău.

Preia rezultatele cu Qiskit
Preia rezultatele pe IBM Quantum Platform

Dacă ai salvat ID-ul job-ului când l-ai trimis, folosește service.job(<job_id>) pentru a-l prelua mai târziu. Dacă nu ai ID-ul job-ului sau dacă vrei să preiei mai multe job-uri odată (inclusiv job-uri de la QPU-uri retrase), folosește în schimb service.jobs(), cu filtre opționale.

Consultă documentația API QiskitRuntimeService.jobs pentru filtrele disponibile.

Acest exemplu demonstrează preluarea rezultatelor recente rulate pe un backend specific.

Preia proprietățile backend-ului

Preia proprietățile backend-ului cu Qiskit
Preia proprietățile backend-ului pe IBM Quantum Platform

Poți folosi job.properties() pentru a prelua proprietățile backend-ului, inclusiv ratele de eroare, la momentul execuției job-ului.

Acest exemplu demonstrează cum să preiei proprietățile backend-ului care erau valabile la momentul execuției unui job, inclusiv timpii $T_1$ / $T_2$ și ratele de eroare pentru un qubit specific (0).

Pachete de furnizori depreciate

service.jobs() returnează, de asemenea, job-uri rulate din pachetul depreciat qiskit-ibm-provider. Job-urile trimise de pachetul mai vechi (de asemenea depreciat) qiskit-ibmq-provider nu mai sunt disponibile.

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

Anulează un job

Anulează un job care este în așteptare sau în execuție. Odată ce un job este anulat, acesta nu poate fi reluat.

Anulează cu Qiskit
Anulează pe IBM Quantum Platform

Folosește metoda job.cancel() pentru a anula un job programatic.

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

Pași următori

Recomandări

Consultă referința API QiskitRuntimeService pentru metode suplimentare de gestionare a job-urilor.
Explorează modurile de execuție pentru a înțelege tipurile de sarcini de lucru batch și session.

Monitorizează un job​

De ce un job rămâne "In progress"​

Modul session este diferit​

Vizualizează utilizarea rămasă​

Vizualizează metricile job-urilor​

Recuperează rezultatele unui job la o dată ulterioară​

Preia proprietățile backend-ului​

Anulează un job​

Pași următori​