Memantau atau membatalkan job

Panduan ini menjelaskan cara memantau status job, melihat informasi penggunaan, dan membatalkan job. Kamu bisa mengakses informasi ini baik melalui IBM Quantum® Platform maupun secara programatik menggunakan Qiskit.

Versi paket

Kode pada halaman ini dikembangkan menggunakan persyaratan berikut. Kami menyarankan untuk menggunakan versi ini atau yang lebih baru.

qiskit-ibm-runtime~=0.46.1

Pantau job

Gunakan metode berikut untuk memeriksa status job yang kamu kirimkan, mengambil hasil, dan melihat detail terkait job serta eksekusinya.

Pantau job dengan Qiskit
Pantau job di IBM Quantum Platform

Instance job menyediakan beberapa metode untuk pemantauan:

Metode	Deskripsi
`job.status()`	Periksa status job saat ini
`job.job_id()`	Dapatkan ID unik job
`job.result()`	Ambil hasil job (blocking call hingga selesai)
`job.wait_for_final_state()`	Memblokir hingga job mencapai keadaan terminal

Mengapa job tetap "In progress"

Kamu mungkin memperhatikan bahwa job (menggunakan mode job maupun mode batch) yang kamu perkirakan hanya membutuhkan beberapa detik tetap berada dalam status In progress (disebut RUNNING di Qiskit) jauh lebih lama. Ini normal, dan tidak berarti job tersebut menggunakan seluruh waktu itu sebagai usage. Hal ini terjadi karena cara job dijadwalkan pada QPU:

Setiap job memerlukan pre-processing klasik sebelum bisa berjalan pada QPU. Job berpindah ke In progress (RUNNING) segera setelah pemrosesan klasik ini dimulai — bukan saat mulai dieksekusi pada QPU.
Sebagian besar pemrosesan klasik ini berjalan secara paralel, sehingga beberapa job bisa berada dalam status In progress pada saat yang sama.
Namun, hanya satu job pada satu waktu yang bisa berjalan pada QPU. Ketika beberapa job selesai dengan pemrosesan klasiknya dan siap untuk dieksekusi, mereka harus menunggu giliran untuk QPU. Ini dikenal sebagai QPU contention. Ketika contention tinggi, sebuah job bisa tetap berada dalam status In progress lebih lama secara signifikan dibandingkan dengan beberapa detik waktu QPU yang sebenarnya dibutuhkan.
Contention juga bisa terjadi ketika tugas pemeliharaan sistem, seperti kalibrasi, sedang berjalan pada QPU. Jobmu tetap berada dalam status In progress hingga tugas pemeliharaan selesai dan QPU menjadi tersedia.

Karena itu, waktu wall-clock yang berlalu saat job berada dalam status In progress tidak sama dengan usage-nya. Baik estimasi usage maupun waktu eksekusi maksimum hanya didasarkan pada waktu QPU terkunci untuk mengeksekusi jobmu, dan karena itu tidak termasuk pemrosesan klasik multi-threaded yang dijelaskan di atas. Waktu In progress yang lama tidak meningkatkan usage atau biaya yang dilaporkan.

Mode session itu berbeda

Perilaku sebelumnya berlaku untuk mode job dan mode batch. Dalam mode session, selama jendela aktif session, pengguna memiliki akses eksklusif ke backend dan tidak ada job lain yang bisa berjalan, termasuk job kalibrasi. Oleh karena itu, QPU contention apa pun hanya terjadi di antara job session milikmu sendiri. Selain itu, karena kapasitas QPU dicadangkan selama durasi session, usage session diukur sebagai waktu yang berlalu selama session tetap aktif, terlepas dari apakah job sedang aktif berjalan atau tidak. Lihat Usage workload untuk informasi lebih lanjut.

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

Lihat sisa penggunaan

Lacak berapa banyak sisa kuota usage dari planmu.

Periksa usage dengan Qiskit
Lihat usage di IBM Quantum Platform

Gunakan metode service.usage() untuk mendapatkan informasi usage untuk instance aktif kamu saat ini.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

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

Lihat metrik job

Dapatkan gambaran umum tentang pengiriman jobmu, termasuk metrik workload batch dan session.

Dapatkan metrik job dengan Qiskit
Lihat metrik job di IBM Quantum Platform

Gunakan metode service.jobs() dengan filter untuk mengambil informasi tentang job yang kamu kirimkan, seperti berapa banyak yang sudah dikirim, apa statusnya, dan kapan job dibuat. Contoh berikut mengambil semua job yang dikirim dalam tujuh hari terakhir dan menghitung total usage dari job-job tersebut.

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

Ambil hasil job di lain waktu

Kamu bisa menyimpan ID job dan mengambil hasilnya nanti, bahkan setelah menutup sessionmu.

Ambil hasil dengan Qiskit
Ambil hasil di IBM Quantum Platform

Jika kamu menyimpan ID job saat mengirimkan job, gunakan service.job(<job_id>) untuk mengambilnya nanti. Jika kamu tidak memiliki ID job, atau jika kamu ingin mengambil beberapa job sekaligus (termasuk job dari QPU yang sudah pensiun), gunakan service.jobs() sebagai gantinya, dengan filter opsional.

Lihat dokumentasi API QiskitRuntimeService.jobs untuk filter yang tersedia.

Contoh ini mendemonstrasikan cara mengambil hasil terbaru yang dijalankan pada backend tertentu.

Ambil properti backend

Ambil properti backend dengan Qiskit
Ambil properti backend di IBM Quantum Platform

Kamu bisa menggunakan job.properties() untuk mengambil properti backend, termasuk error rate, pada saat eksekusi job.

Contoh ini mendemonstrasikan cara mengambil properti backend yang berlaku pada saat job dijalankan, termasuk waktu $T_1$ / $T_2$ dan error rate untuk qubit tertentu (0).

Paket provider yang sudah usang

service.jobs() juga mengembalikan job yang dijalankan dari paket qiskit-ibm-provider yang sudah usang. Job yang dikirim oleh paket qiskit-ibmq-provider yang lebih lama (juga sudah usang) tidak lagi tersedia.

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

Batalkan job

Batalkan job yang sedang antre atau berjalan. Setelah job dibatalkan, job tidak bisa dilanjutkan kembali.

Batalkan dengan Qiskit
Batalkan di IBM Quantum Platform

Gunakan metode job.cancel() untuk membatalkan job secara programatik.

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

Langkah berikutnya

Rekomendasi

Tinjau referensi API QiskitRuntimeService untuk metode manajemen job tambahan.
Jelajahi mode eksekusi untuk memahami tipe workload batch dan session.

Pantau job​

Mengapa job tetap "In progress"​

Mode session itu berbeda​

Lihat sisa penggunaan​

Lihat metrik job​

Ambil hasil job di lain waktu​

Ambil properti backend​

Batalkan job​

Langkah berikutnya​