I-deploy ang una mong managed workflow

Mga bersyon ng package

Ang code sa pahinang ito ay binuo gamit ang mga sumusunod na requirement. Inirerekomenda naming gamitin ang mga bersyong ito o mas bago.

qiskit[all]~=2.6.1
qiskit-serverless~=0.38.0

Gamitin ang pahinang ito para mag-upload ng workflow, patakbuhin ito, at kunin ang resulta nito. Ino-optimize at sinisimulate ng halimbawang workflow ang isang Qiskit circuit. Sinisimulate nito ang circuit sa classical hardware, kaya hindi ito gumagamit ng QPU time.

Bago ka magsimula, i-install ang client package at mag-authenticate.

Gumamit ng AI skills (opsyonal)

Para i-deploy ang sarili mong code na may tulong ng AI assistant, gamitin ang mga AI skill sa Qiskit Function templates repository.

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

Sumulat ng workflow

Gawin ang folder structure

Ang managed workflow ay isang folder ng mga Python file na may isang entrypoint file. Ina-upload ng managed workflow ang lahat ng nasa folder, hanggang 50 MB, at pinapatakbo ang entrypoint bilang script. Dahil ina-upload ng workflow ang buong folder, panatilihin ang iyong mga local file, tulad ng deploy.ipynb, sa labas ng folder. Gawin ang sumusunod na layout:

hello_world_project/
├── deploy.ipynb         # Your local notebook: upload and run the workflow
└── source_files/         # The working directory that you upload
    └── hello_world.py   # The entrypoint

Isulat ang hello world entrypoint

Binabasa ng entrypoint ang isang circuit, ino-optimize at sinisimulate ito, at sine-save ang mga count at ang two-qubit depth. I-save ang sumusunod na code bilang source_files/hello_world.py:

tala

Kung binabasa mo ang pahinang ito bilang notebook, nagsisimula ang code cell para sa hello_world.py sa %%writefile magic command. Kapag pinatakbo mo ang cell na ito, sine-save nito ang code sa file sa halip na patakbuhin ang code.

# 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/hello_world.py
from qiskit.primitives import StatevectorSampler
from qiskit.transpiler import generate_preset_pass_manager
from qiskit_serverless import Job, get_arguments, save_result, update_status

# Read the arguments that you pass to run()
arguments = get_arguments()
circuit = arguments["circuit"]
shots = arguments.get("shots", 1024)

# Optimize the circuit. Printed text goes to the job's logs.
update_status(Job.OPTIMIZING_HARDWARE)
pass_manager = generate_preset_pass_manager(
    optimization_level=1, basis_gates=["cz", "rz", "sx", "x"]
)
isa_circuit = pass_manager.run(circuit)
two_qubit_depth = isa_circuit.depth(lambda instruction: instruction.operation.num_qubits == 2)
print(f"Two-qubit depth after optimization: {two_qubit_depth}", flush=True)

# Simulate the circuit and return the counts
sampler = StatevectorSampler(seed=1234)
pub_result = sampler.run([isa_circuit], shots=shots).result()[0]
save_result({"counts": pub_result.data.meas.get_counts(), "two_qubit_depth": two_qubit_depth})

Writing ./source_files/hello_world.py

Gumagamit ang entrypoint ng tatlong function mula sa qiskit_serverless:

• Ibinabalik ng get_arguments() ang mga keyword argument na ipinapasa mo sa run(), bilang dictionary. Dapat JSON-serializable ang bawat value, o isang object na kayang i-encode ng client, tulad ng QuantumCircuit. Dumarating ang mga na-encode na object bilang parehong mga object na ipinasa mo.

• Itinatakda ng update_status(Job.OPTIMIZING_HARDWARE) ang detalyadong status na RUNNING: OPTIMIZING_FOR_HARDWARE, na makikita mo habang tumatakbo ang job. Tingnan ang Report progress with update_status().

• Iniimbak ng save_result() ang isang JSON-serializable na value na babasahin mo mamaya gamit ang job.result(). Ibinabalik ng workflow ang mga count bilang dictionary at ang two-qubit depth ng na-optimize na circuit bilang integer.

Anumang isinusulat ng workflow sa standard output, tulad ng two-qubit depth, ay napupunta sa mga log ng job. Para magdagdag ng mga timestamp at log level, gamitin ang logging module. Tingnan ang Write logs and handle errors.

I-upload ang workflow

Sa iyong local notebook, patakbuhin ang sumusunod na code mula sa folder na hello_world_project. Kumokonekta ang code gamit ang iyong naka-save na account, dine-define ang workflow, at ina-upload ito. Ang entrypoint ay ang file na pinapatakbo ng workflow, at ang working_dir ay ang folder na ina-upload mo:

from qiskit_ibm_catalog import ManagedWorkflow, ManagedWorkflowClient

client = ManagedWorkflowClient()

hello_world = ManagedWorkflow(
    title="hello-world",
    entrypoint="hello_world.py",
    working_dir="./source_files/",
)

hello_world = client.upload(hello_world)

Patakbuhin ang workflow gamit ang mga input

Gumawa ng three-qubit GHZ circuit na ipapasa sa hello_world bilang input:

from qiskit import QuantumCircuit

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

Patakbuhin ang hello_world gamit ang circuit at ang bilang ng mga shot bilang mga keyword argument. Tumutugma ang mga pangalan ng argument sa mga key na binabasa ng entrypoint gamit ang get_arguments():

job = hello_world.run(circuit=circuit, shots=1024)
print(job.job_id)

54705348-5117-44b7-935b-e6986ef182fa

Nagbabalik ang run() ng Job pagkatapos i-queue ng workflow ang job. Hindi ito naghihintay na tumakbo ang job. Magpapatuloy ang job sa cloud pagkatapos mong isara ang iyong Python session. Para hanapin ito ulit mamaya, ilista ang iyong mga kamakailang job gamit ang client.jobs().

Kunin ang status, result, at mga log

Pagkatapos mismo ng pagtawag mo sa run(), karaniwang QUEUED ang status:

job.status()

'QUEUED'

Nagbabago ang status mula QUEUED patungong INITIALIZING, RUNNING, at pagkatapos ay DONE.

Naghihintay ang job.result() hanggang matapos ang job, pagkatapos ay ibinabalik ang value na ipinasa ng workflow sa save_result():

job.result()

{'counts': {'111': 514, '000': 510}, 'two_qubit_depth': 2}

# This cell is hidden from users. It checks the result.
assert set(_["counts"]) <= {"000", "111"}  # noqa: F821
assert sum(_["counts"].values()) == 1024  # noqa: F821

from qiskit.visualization import plot_histogram

plot_histogram(job.result()["counts"])

Puwede mong basahin ang mga log habang tumatakbo ang job. Nag-a-upload ang workflow ng mga bagong linya tuwing mga 15 segundo. Kasama sa mga log ang linyang pinrint ng workflow:

print(job.logs())

Two-qubit depth after optimization: 2

# This cell is hidden from users. It checks the logs.
assert "Two-qubit depth after optimization" in job.logs()

I-update ang workflow

Para baguhin ang isang workflow, i-edit ang mga file nito at tawagin muli ang upload() gamit ang parehong title. Pinapalitan ng bagong upload ang nauna, at hindi naaapektuhan ang mga job na nagsimula na.

Ang mga field tulad ng arguments_schema at sizes_map ay nananatili ang kanilang mga naka-store na value kapag inalis mo ang mga ito sa bagong upload.

Mga susunod na hakbang

Mga Rekomendasyon

• Define inputs and outputs para malaman kung anong mga uri ng argument at result ang sinusuportahan ng workflow.
• Declare dependencies para gumamit ng mas maraming Python package sa iyong workflow.
• Run quantum jobs from a workflow para patakbuhin ang iyong mga circuit sa isang QPU, i-report ang bawat stage, at subaybayan ang mga QPU job.
• Run a managed workflow para malaman ang lahat ng job status, i-debug ang bigong job, at hanapin ang isang job mamaya.
• Para magsimula sa gumaganang code, i-deploy ang isa sa mga Qiskit Function templates, o i-adapt ang isang template para sa sarili mong workflow.