Jalankan job kuantum daripada aliran kerja

Versi pakej

Kod pada halaman ini dibangunkan menggunakan keperluan berikut. Kami mengesyorkan penggunaan versi ini atau yang lebih baharu.

qiskit[all]~=2.6.1
qiskit-ibm-runtime~=0.51.0
qiskit-serverless~=0.38.0

Aliran kerja kuantum-klasik berjalan sebagai satu job aliran kerja terurus. Peringkat klasiknya berjalan pada profil pengkomputeran anda, dan job primitif yang dihantarnya ke QPU IBM Quantum® berjalan pada instance anda dan dikira dalam penggunaan anda. Daripada satu job itu, anda boleh melaporkan setiap peringkat, mencari job QPU dan membatalkannya. Untuk memulakan job dan menyemak status serta lognya, lihat Jalankan aliran kerja terurus.

Sebelum anda bermula, gunakan aliran kerja terurus pertama anda.

Cipta perkhidmatan Runtime

Cipta perkhidmatan Runtime dalam kod aliran kerja anda dengan get_runtime_service(), dan gunakannya dengan cara yang sama seperti anda menggunakan QiskitRuntimeService secara setempat. Aliran kerja berikut menjalankan litar Bell dengan primitif Sampler, melaporkan setiap peringkat dengan update_status(), dan mengembalikan kiraan:

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"qiskit": "qiskit", "qiskit_ibm_catalog": "qiskit-ibm-catalog", "qiskit_ibm_runtime": "qiskit-ibm-runtime", "qiskit_serverless": "qiskit-serverless"}
_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")

# This cell is hidden from users. It creates the working directory.
from pathlib import Path

Path("./source_files").mkdir(exist_ok=True)

%%writefile ./source_files/my_workflow.py
from qiskit import QuantumCircuit
from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime.executor_sampler import Sampler
from qiskit_serverless import (
    Job,
    get_arguments,
    get_runtime_service,
    save_result,
    update_status,
)

arguments = get_arguments()

service = get_runtime_service()
backend = service.backend(arguments["backend_name"])

circuit = QuantumCircuit(2)
circuit.h(0)
circuit.cx(0, 1)
circuit.measure_all()

update_status(Job.OPTIMIZING_HARDWARE)
pass_manager = generate_preset_pass_manager(optimization_level=1, backend=backend)
isa_circuit = pass_manager.run(circuit)

update_status(Job.WAITING_QPU)
sampler = Sampler(mode=backend)
primitive_job = sampler.run([isa_circuit])
counts = primitive_job.result()[0].data.meas.get_counts()

update_status(Job.POST_PROCESSING)
save_result({"backend": backend.name, "counts": counts})

Overwriting ./source_files/my_workflow.py

get_runtime_service() mengembalikan QiskitRuntimeService yang disediakan untuk job aliran kerja terurus anda, dan ia menyediakan perkara berikut:

• Bukti kelayakan. Perkhidmatan Runtime menggunakan kunci API, instance dan saluran yang anda gunakan untuk memanggil run(), jadi kod aliran kerja tidak memerlukan bukti kelayakan.

• Penjejakan. Aliran kerja merekodkan setiap job primitif yang berjalan melalui perkhidmatan Runtime ini di bawah job aliran kerja terurus, termasuk job Sampler, Estimator dan Executor, serta job dalam session atau batch. Anda boleh menyenaraikannya dengan job.runtime_jobs().

• Pembatalan. Apabila anda memanggil job.cancel(), aliran kerja terurus turut membatalkan session, batch dan job primitif aliran kerja yang masih berjalan.

Aliran kerja terurus tidak menjejak atau membatalkan job bagi perkhidmatan yang anda cipta dengan QiskitRuntimeService(), walaupun job itu tetap berjalan. Jika aliran kerja mesti menggunakan perkhidmatan lain, batalkan jobnya dalam pengendali SIGTERM.

Jalankan primitif dalam session atau batch

Aliran kerja terurus turut menjejak job primitif yang berjalan dalam session atau batch. Cipta session atau batch daripada backend yang dikembalikan oleh perkhidmatan Runtime, dan cipta primitif di dalam blok with. Session berfungsi dengan cara yang sama:

source_files/my_workflow.py

from qiskit_ibm_runtime import Batch

with Batch(backend=backend) as batch:
    sampler = Sampler(mode=batch)
    primitive_jobs = [sampler.run([isa_circuit]) for _ in range(2)]
    results = [primitive_job.result() for primitive_job in primitive_jobs]

Laporkan kemajuan dengan update_status()

Aliran kerja dalam Cipta perkhidmatan Runtime memanggil update_status() pada permulaan setiap peringkat, supaya status job menunjukkan kedudukan aliran kerja, seperti RUNNING: WAITING_FOR_QPU. Hantar salah satu pemalar Job berikut:

Panggilan dalam aliran kerja	Status job
update_status(Job.MAPPING)	RUNNING: MAPPING
update_status(Job.OPTIMIZING_HARDWARE)	RUNNING: OPTIMIZING_FOR_HARDWARE
update_status(Job.WAITING_QPU)	RUNNING: WAITING_FOR_QPU
update_status(Job.EXECUTING_QPU)	RUNNING: EXECUTING_QPU
update_status(Job.POST_PROCESSING)	RUNNING: POST_PROCESSING

update_status() mengembalikan True jika aliran kerja mengubah status. Ia mengembalikan False dan menulis amaran ke log jika nilainya bukan salah satu pemalar ini, jika job tidak lagi aktif, atau jika kod berjalan di luar job. Ia tidak menimbulkan ralat, jadi kesilapan menaip tidak menghentikan aliran kerja.

Untuk kemajuan dalam sesuatu peringkat, seperti lelaran pengoptimum, tulis baris log.

Cari job QPU bagi sesuatu larian

Dalam buku nota setempat anda, pilih QPU yang boleh diakses oleh instance anda. client.backends() menyenaraikannya, dan client.least_busy() mengembalikan yang mempunyai paling sedikit job menunggu:

from qiskit_ibm_catalog import ManagedWorkflowClient

client = ManagedWorkflowClient()
print([backend.name for backend in client.backends(simulator=False)])

backend_name = client.least_busy(operational=True, simulator=False).name

['ibm_boston', 'ibm_fez', 'ibm_kingston', 'ibm_marrakesh', 'ibm_phoenix', 'ibm_pittsburgh']

Muat naik aliran kerja, dan hantar nama backend apabila anda menjalankannya:

from qiskit_ibm_catalog import ManagedWorkflow

my_workflow = client.upload(
    ManagedWorkflow(
        title="my-workflow",
        entrypoint="my_workflow.py",
        working_dir="./source_files/",
    )
)

job = my_workflow.run(backend_name=backend_name)

# This cell is hidden from users. It waits for the job to finish.
assert job.wait_for_final_state() == "DONE", job.logs()

Selepas job tamat, dapatkan ID job QPU aliran kerja daripada job aliran kerja terurus:

runtime_job_ids = job.runtime_jobs()
runtime_job_ids

['dbl6lst8ft8s738secf0']

# This cell is hidden from users. It checks the tracked job.
assert len(runtime_job_ids) == 1, runtime_job_ids

Setiap ID ialah ID job primitif biasa. Untuk membaca status dan keputusan sesuatu job, lihat Dapatkan semula keputusan job pada masa kemudian. Jika aliran kerja menjalankan primitif dalam session atau batch, senaraikan ID session dan batch dengan runtime_sessions(), dan hantar salah satu kepada runtime_jobs() untuk mendapatkan hanya job di dalamnya:

run_workflow_remotely.ipynb

for session_id in job.runtime_sessions():
    print(session_id, job.runtime_jobs(session_id))

dc101077-d085-40fb-8fbe-78852e355994 ['dbjqp48nceqs73aki1k0', 'dbjqp4l6p51s73clb91g']

Objek job hanya wujud dalam buku nota yang memulakan larian. Dalam buku nota baharu, dapatkan semula job dengan client.job("<your-job-id>"), kemudian panggil runtime_jobs() padanya. Lihat Cari job daripada session baharu.

Untuk penggunaan QPU dan masa larian setiap job QPU, lihat Lihat metrik job. Untuk penggunaan seluruh instance anda dalam tempoh semasa, panggil client.usage(). Untuk melihat berapa lama setiap peringkat job aliran kerja terurus mengambil masa, lihat Semak berapa lama setiap peringkat mengambil masa.

Batalkan job QPU yang dipautkan

Apabila anda membatalkan job aliran kerja terurus dengan job.cancel(), aliran kerja turut cuba membatalkan kerja QPU yang dimulakan oleh aliran kerja:

• Session dan batch. Aliran kerja membatalkan setiap session dan batch aliran kerja, yang turut membatalkan job mereka yang beratur.

• Job primitif lain. Aliran kerja membatalkan setiap job primitif lain aliran kerja yang masih beratur atau berjalan.

job.cancel() mengembalikan mesej bagi setiap job QPU dan session, supaya anda boleh menyemak apa yang dibatalkan:

run_workflow_remotely.ipynb

print(job.cancel())

Bagi aliran kerja yang berjalan dalam batch, mesejnya kelihatan seperti berikut:

Job is stopping. Canceled runtime session: eb8874c9-a15e-45f8-9a90-a9fb35267f9d and associated runtime jobs.

Jika klien tidak dapat mencipta QiskitRuntimeService daripada bukti kelayakan setempat anda, ia hanya membatalkan job aliran kerja terurus. Batalkan sendiri job QPU dengan ID mereka daripada job.runtime_jobs().

Apabila aliran kerja menghentikan job sendiri, contohnya kerana ia mencapai had 24 jam, ia tidak membatalkan job QPUnya. Batalkannya dengan ID mereka daripada job.runtime_jobs().

Selesaikan masalah job QPU dalam aliran kerja

Masalah	Punca
get_runtime_service() menimbulkan KeyError: 'QISKIT_IBM_CHANNEL'.	Kod berjalan dalam buku nota setempat anda, bukan dalam job aliran kerja terurus. Gunakan QiskitRuntimeService() secara setempat.
update_status() mengembalikan False, dan log menunjukkan 'sub_status' not provided or is not valid.	Nilainya bukan salah satu pemalar Job, atau job tidak lagi aktif.
job.runtime_jobs() mengembalikan [].	Aliran kerja mencipta perkhidmatannya dengan QiskitRuntimeService(), atau ia belum menjalankan primitif lagi.
Job sesuatu session tidak dijejak.	Session dicipta daripada backend perkhidmatan yang berbeza. Dapatkan backend daripada get_runtime_service().
Log aliran kerja menunjukkan Could not associate runtime job with serverless job.	Aliran kerja tidak dapat merekodkan job primitif. Job primitif tetap berjalan, tetapi tidak dijejak.
job.cancel() menunjukkan No QiskitRuntimeService can be associated to the given token and instance.	Klien tidak dapat mencipta QiskitRuntimeService daripada bukti kelayakan setempat anda, jadi ia hanya membatalkan job aliran kerja terurus.
client.job() gagal dengan Job [...] not found.	ID job salah, atau job itu milik pengguna lain.

Langkah seterusnya

Cadangan

• Jalankan aliran kerja terurus untuk menyemak status, keputusan dan log sesuatu job, dan mencari punca ralat.