I-monitor o i-cancel ang isang job

Ipinapaliwanag ng gabay na ito kung paano subaybayan ang status ng job, tingnan ang impormasyon ng paggamit, at kanselahin ang mga job. Maa-access mo ang impormasyong ito sa pamamagitan ng IBM Quantum® Platform at programmatically gamit ang Qiskit.

Mga bersyon ng package

Ang code sa pahinang ito ay binuo gamit ang mga sumusunod na requirement. Inirerekomenda namin ang paggamit ng mga bersyong ito o mas bago.

qiskit-ibm-runtime~=0.46.1

I-monitor ang isang job

Gamitin ang mga method na ito para suriin ang status ng iyong mga isinumiteng job, kunin ang mga resulta, at tingnan ang mga detalye na kaugnay ng job at ng pagpapatakbo nito.

Monitor a job with Qiskit

Nagbibigay ang job instance ng ilang method para sa pagsubaybay:

Method	Deskripsyon
job.status()	Tingnan ang kasalukuyang status ng job
job.job_id()	Kunin ang natatanging identifier ng job
job.result()	Kunin ang mga resulta ng job (blocking call hanggang matapos)
job.wait_for_final_state()	Mag-block hanggang maabot ng job ang terminal state

Monitor a job on IBM Quantum Platform

Pumunta sa Workloads page at tingnan ang Status column. Ang status ng iyong job ay makikita bilang isa sa mga sumusunod:

• Pending: Job is waiting to run on a QPU
• In progress: Job is currently executing
• Completed: Job finished successfully
• Failed: Job encountered an error
• Canceled: User canceled the job

I-click ang job name o row para buksan ang detailed view, kung saan makikita mo ang impormasyon tulad ng mga resulta at anumang mga error message.

Bakit nananatiling "In progress" ang isang job

Mapapansin mo na ang isang job (gamit man ang job mode o batch mode) na inaasahan mong ilang segundo lang ang tatagal ay nananatili sa In progress status (tinatawag na RUNNING sa Qiskit) nang mas matagal. Normal ito, at hindi ito nangangahulugan na ginagamit ng job ang buong oras na iyon bilang usage. Nangyayari ito dahil sa kung paano naka-iskedyul ang mga job papunta sa isang QPU:

• Kailangan ng bawat job ng classical pre-processing bago ito makapagpatakbo sa QPU. Ang isang job ay lumilipat sa In progress (RUNNING) sa sandaling magsimula ang classical processing na ito — hindi kapag nagsisimula itong mag-execute sa QPU.

• Karamihan sa classical processing na ito ay tumatakbo nang parallel, kaya maaaring In progress ang maraming job nang sabay-sabay.

• Gayunpaman, isang job lang sa isang pagkakataon ang maaaring tumakbo sa QPU. Kapag natapos na ng ilang job ang kanilang classical processing at handa nang mag-execute, kailangan nilang maghintay ng turno para sa QPU. Ito ay tinatawag na QPU contention. Kapag mataas ang contention, maaaring manatiling In progress ang isang job nang mas matagal kumpara sa ilang segundong QPU time na talagang kailangan nito.

• Maaari ring mangyari ang contention kapag may tumatakbong system-maintenance task, tulad ng calibration, sa QPU. Mananatiling In progress ang iyong job hanggang matapos ang maintenance task at maging available ang QPU.

Dahil dito, ang naubos na wall-clock time ng isang job habang In progress ay hindi katumbas ng usage nito. Ang parehong estimated usage at maximum execution time ay batay lamang sa oras na naka-lock ang QPU para i-execute ang iyong job, at dahil dito hindi kasama ang multi-threaded classical processing na inilarawan sa itaas. Ang mahabang In progress na oras ay hindi nagpapataas ng iyong naiuulat na usage o gastos.

Iba ang session mode

Ang naunang paguugali ay naaangkop sa job mode at batch mode. Sa session mode, sa panahon ng active window ng session, eksklusibong access lang ang mayroon ang user sa backend at walang ibang job ang maaaring tumakbo, kabilang ang mga calibration job. Dahil dito, ang anumang QPU contention ay nangyayari lamang sa pagitan ng iyong sariling mga session job. Bukod dito, dahil nakareserba ang QPU capacity sa buong tagal ng session, ang session usage ay sinusukat bilang naubos na oras habang aktibo ang session, anuman ang status ng mga tumatakbong job. Tingnan ang Workload usage para sa karagdagang impormasyon.

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

Tingnan ang natitirang paggamit

Subaybayan kung gaano karami ang natitira sa usage quota ng iyong plano.

Check usage with Qiskit

Gamitin ang service.usage() method para makuha ang impormasyon ng usage para sa iyong kasalukuyang active instance.

View usage on IBM Quantum Platform

Pumunta sa Instances page at piliin ang tab na nauugnay sa plano na gusto mong tingnan. Ipinapakita ang kabuuang oras na ginamit at kabuuang oras na natitira sa iyong plano.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

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

Tingnan ang mga metrics ng job

Kumuha ng overview ng iyong mga pagsumite ng job, kabilang ang batch at session workload metrics.

Get job metrics with Qiskit

Gamitin ang service.jobs() method na may mga filter para makuha ang impormasyon tungkol sa iyong mga isinumiteng job, tulad ng kung ilan ang naisumite, ano ang kanilang status, at kailan sila ginawa. Ang sumusunod na halimbawa ay kumukuha ng lahat ng job na isinumite sa nakaraang pitong araw at kinakalkula ang kabuuang usage mula sa mga job na iyon.

View job metrics on IBM Quantum Platform

Pumunta sa Analytics page para makita at ma-download ang data, tulad ng mga sumusunod:

• Total usage
• Usage filtered by instance, quantum computer, and user
• Count of job, batch, and session workloads

Tandaan: Maa-access mo lang ang Analytics page para sa mga account na pagmamay-ari mo o pinapamahalaan mo.

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

Kunin ang mga resulta ng job sa ibang pagkakataon

Maaari mong i-save ang mga job ID at kunin ang mga resulta sa ibang pagkakataon, kahit pagkatapos isara ang iyong session.

Retrieve results with Qiskit

Kung na-save mo ang job ID nang isinumite mo ang job, gamitin ang service.job(<job_id>) para kunin ito sa ibang pagkakataon. Kung wala kang job ID, o kung gusto mong kunin ang maraming job nang sabay-sabay (kabilang ang mga job mula sa mga retired QPU), gamitin ang service.jobs() sa halip, na may mga opsyonal na filter.

Tingnan ang QiskitRuntimeService.jobs API documentation para sa mga available na filter.

Ipinapakita ng halimbawang ito ang pagkuha ng mga kamakailang resulta na pinatakbo sa isang partikular na backend.

Retrieve results on IBM Quantum Platform

1. Pumunta sa Workloads page.
2. Gamitin ang search o filter options para hanapin ang iyong job ayon sa pangalan, petsa, o status.
3. I-click ang job para tingnan ang mga resulta at detalye nito.

Kunin ang mga property ng backend

Retrieve backend properties with Qiskit

Maaari mong gamitin ang job.properties() para kunin ang mga property ng backend, kabilang ang mga error rate, sa oras ng pagpapatakbo ng job.

Ipinapakita ng halimbawang ito kung paano kunin ang mga property ng backend na kasalukuyan noong pinapatakbo ang isang job, kabilang ang mga $T_1$/$T_2$ na oras at error rate para sa isang partikular na qubit (0).

Mga deprecated na provider package

Ibinabalik din ng service.jobs() ang mga job na pinatakbo mula sa deprecated na qiskit-ibm-provider package. Ang mga job na isinumite ng mas lumang (deprecated rin) qiskit-ibmq-provider package ay hindi na available.

Retrieve backend properties on IBM Quantum Platform

Makikita mo ang calibration data para sa backend sa oras ng pagpapatakbo ng job, gayundin sa oras ng paggawa ng job.

1. Pumunta sa Workloads page
2. I-click ang isang workload para buksan ang Details page nito
3. Sa ilalim ng Quantum computer, i-click ang View calibration history
4. Gamitin ang dropdown menu para lumipat mula sa pagtingin ng data na "At job execution start" patungo sa "At job creation"

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

I-cancel ang isang job

Kanselahin ang isang job na naka-queue o tumatakbo. Kapag nakansela na ang isang job, hindi na ito maaaring ipagpatuloy.

Cancel with Qiskit

Gamitin ang job.cancel() method para kanselahin ang isang job nang programmatic.

Cancel on IBM Quantum Platform

1. From the workloads table: I-click ang overflow menu sa dulo ng row para sa workload na gusto mong kanselahin, at piliin ang Cancel.
2. From the job details page: I-click ang workload para buksan ang details page nito, gamitin ang Actions dropdown sa itaas, at piliin ang Cancel.

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

Mga susunod na hakbang

Mga Rekomendasyon

• Suriin ang QiskitRuntimeService API reference para sa mga karagdagang method ng pamamahala ng job.
• Galugarin ang execution modes para maintindihan ang mga uri ng batch at session workload.