Isulat ang iyong unang Qiskit Serverless na programa

Package versions

Ang code sa page na ito ay ginawa gamit ang mga sumusunod na requirements. Inirerekomenda naming gamitin ang mga bersyong ito o mas bago.

qiskit[all]~=1.3.1
qiskit-ibm-runtime~=0.34.0
qiskit-aer~=0.15.1
qiskit-serverless~=0.27.0
qiskit-ibm-catalog~=0.2
qiskit-addon-sqd~=0.8.1
qiskit-addon-utils~=0.1.0
qiskit-addon-mpf~=0.2.0
qiskit-addon-aqc-tensor~=0.1.2
qiskit-addon-obp~=0.1.0
scipy~=1.15.0
pyscf~=2.8.0

tip

Ina-upgrade ang Qiskit Serverless, at mabilis na nagbabago ang mga feature nito. Sa panahon ng development phase na ito, hanapin ang mga release note at pinakabagong dokumentasyon sa pahina ng Qiskit Serverless GitHub.

Ang halimbawang ito ay nagpapakita kung paano gamitin ang mga tool ng qiskit-serverless para gumawa ng parallel transpilation na programa, at pagkatapos ay gamitin ang qiskit-ibm-catalog para i-upload ang iyong programa sa IBM Quantum Platform bilang reusable remote service.

Pangkalahatang-ideya ng workflow

1. Gumawa ng lokal na direktoryo at walang laman na program file (./source_files/transpile_remote.py)

2. Magdagdag ng code sa iyong programa na, kapag na-upload sa Qiskit Serverless, ay nagta-transpile ng circuit

3. Gamitin ang qiskit-ibm-catalog para mag-authenticate sa Qiskit Serverless

4. I-upload ang programa sa Qiskit Serverless

Pagkatapos ma-upload ang iyong programa, maaari mo itong patakbuhin para ma-transpile ang circuit sa pamamagitan ng pagsunod sa gabay na Patakbuhin ang iyong unang Qiskit Serverless workload nang remote.

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

Halimbawa: Remote transpilation gamit ang Qiskit Serverless

Ang halimbawang ito ay ginagabayan ka sa paglikha at pagdaragdag sa isang program file na, kapag na-upload mo sa Qiskit Serverless, ay nagta-transpile ng circuit laban sa isang ibinigay na backend at target na optimization_level.

tip

Kailangan ng Qiskit Serverless na i-set up ang mga .py file ng iyong workload sa isang dedicated na direktoryo. Ang sumusunod na istruktura ay halimbawa ng magandang gawi:

serverless_program
├── program_uploader.ipynb
└── source_files
├── transpile_remote.py
└── *.py

Ina-upload ng Serverless ang mga nilalaman ng isang partikular na direktoryo (sa halimbawang ito, ang source_files na direktoryo) para patakbuhin nang remote. Pagkatapos ma-set up ang mga ito, maaari mong baguhin ang transpile_remote.py para kumuha ng mga input at magbalik ng mga output.

Gumawa ng direktoryo at walang laman na program file

Una, gumawa ng direktoryo na pinangalanang source_files, pagkatapos ay gumawa ng program file sa direktoryo, upang ang path nito ay ./source_files/transpile_remote.py. Ito ang file na ia-upload mo sa Qiskit Serverless.

Magdagdag ng code sa iyong program file

Punan ang iyong program file ng sumusunod na code, pagkatapos i-save ito.

babala

Kung binabasa mo ang mga code cell nang lokal sa notebook, makikita mo ang %%writefile magic command. Ang pagpapatupad ng mga cell na may magic command na ito ay nagse-save ng mga ito sa disk sa halip na i-execute ang mga ito.

# This cell is hidden from users, it creates a new folder
from pathlib import Path

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

%%writefile ./source_files/transpile_remote.py
# If you include the preceding `%%writefile` command (visible only when you read this
# locally in a notebook), running this cell saves to disk rather than executing the code.

from qiskit.transpiler import generate_preset_pass_manager

def transpile_remote(circuit, optimization_level, backend):
    """Transpiles an abstract circuit into an ISA circuit for a given backend."""
    pass_manager = generate_preset_pass_manager(
        optimization_level=optimization_level,
		backend=backend
    )
    isa_circuit = pass_manager.run(circuit)
    return isa_circuit

Magdagdag ng code para makuha ang mga argumento ng programa

Ngayon, idagdag ang sumusunod na code sa iyong program file, na nagtatakda ng mga argumento ng programa.

Ang iyong paunang transpile_remote.py ay may tatlong input: circuits, backend_name, at optimization_level. Sa ngayon, serializable na input at output lang ang tinatanggap ng Serverless. Dahil dito, hindi mo maaaring direktang ipasa ang backend, kaya sa halip, gamitin ang backend_name bilang string.

%%writefile --append ./source_files/transpile_remote.py
# If you include the preceding `%%writefile` command (visible only when you read this
# locally in a notebook), running this cell saves to disk rather than executing the code.

from qiskit_serverless import get_arguments, save_result, distribute_task, get

# Get program arguments
arguments = get_arguments()
circuits = arguments.get("circuits")
backend_name = arguments.get("backend_name")
optimization_level = arguments.get("optimization_level")

Magdagdag ng code na tumatawag sa backend

Idagdag ang sumusunod na code sa iyong program file, na kumukuha ng runtime service at ginagamit ito upang piliin ang iyong backend.

Gamitin ang get_runtime_service sa loob ng mga Qiskit Serverless program

Sa loob ng code na tumatakbo sa Qiskit Serverless, gawin ang iyong runtime service gamit ang get_runtime_service() (na-import mula sa qiskit_serverless) sa halip na direktang mag-instantiate ng QiskitRuntimeService().

Ang get_runtime_service() ay nagbabalik ng drop-in wrapper sa paligid ng QiskitRuntimeService na nagpaparehistro ng bawat IBM Quantum primitive job at session na inilulunsad nito laban sa parent na Qiskit Serverless job. Ang koneksyon na ito ang nagbibigay-daan sa platform na iugnay ang isang Serverless job sa mga QPU job at session na nililikha nito, para sa status tracking, logs, at usage at accounting. Ang isang bare na QiskitRuntimeService ay nagsusumite ng mga job na hindi kailanman iniuugnay ng platform sa iyong Serverless job, kaya nawawala ang koneksyong iyon.

Opsyonal ang lahat ng argumento. Sa loob ng program source, ang inirerekomendang anyo ay get_runtime_service() nang walang argumento, na kumukuha ng iyong authentication data mula sa environment. Tinatanggap nito ang parehong opsyonal na mga argumentong channel, token, instance, at url gaya ng QiskitRuntimeService.

Ipinapalagay ng sumusunod na code na naisagawa mo na ang proseso ng pag-save ng iyong credentials gamit ang QiskitRuntimeService.save_account, at maglo-load ng iyong default na naka-save na account maliban kung mag-specify ka ng iba. Tingnan ang I-save ang iyong mga login credential at I-initialize ang iyong IBM Quantum Compute Service account para sa karagdagang impormasyon.

%%writefile --append ./source_files/transpile_remote.py
# If you include the preceding `%%writefile` command (visible only when you read this
# locally in a notebook), running this cell saves to disk rather than executing the code.

from qiskit_serverless import get_runtime_service

service = get_runtime_service()
backend = service.backend(backend_name)

Magdagdag ng code para mag-transpile

Sa wakas, idagdag ang sumusunod na code sa iyong program file. Ang code na ito ay nagpapatakbo ng transpile_remote() sa lahat ng circuits na ipinasa, at ibinabalik ang transpiled_circuits bilang resulta:

%%writefile --append ./source_files/transpile_remote.py
# If you include the preceding `%%writefile` command (visible only when you read this
# locally in a notebook), running this cell saves to disk rather than executing the code.

# Each circuit is being transpiled and will populate the array
results = [
    transpile_remote(circuit, 1, backend)
    for circuit in circuits
]

save_result({
    "transpiled_circuits": results
})

Mag-authenticate sa Qiskit Serverless

Gamitin ang qiskit-ibm-catalog para mag-authenticate sa QiskitServerless gamit ang iyong API key (maaari mong gamitin ang iyong QiskitRuntimeService API key, o gumawa ng bagong API key sa IBM Quantum Platform dashboard).

from qiskit_ibm_catalog import QiskitServerless, QiskitFunction

# Authenticate to the remote cluster and submit the pattern for remote execution
serverless = QiskitServerless()

Patakbuhin ang code para mag-upload

Patakbuhin ang sumusunod na code para i-upload ang programa. Kino-compress ng Qiskit Serverless ang mga nilalaman ng working_dir (sa kasong ito, source_files) sa isang tar, na ina-upload at pagkatapos ay nililinis. Tinutukoy ng entrypoint ang pangunahing executable na programa para patakbuhin ng Qiskit Serverless.

transpile_remote_demo = QiskitFunction(
    title="transpile_remote_serverless",
    entrypoint="transpile_remote.py",
    working_dir="./source_files/",
)

serverless.upload(transpile_remote_demo)

QiskitFunction(transpile_remote_serverless)

I-verify ang upload

Para tingnan kung matagumpay na na-upload, gamitin ang serverless.list(), gaya ng sa sumusunod na code:

# Get program from serverless.list() that matches the title of the one we uploaded
next(
    program
    for program in serverless.list()
    if program.title == "transpile_remote_serverless"
)

QiskitFunction(transpile_remote_serverless)

# This cell is hidden from users, it checks the program uploaded correctly
assert _.title == "transpile_remote_serverless"  # noqa: F821

# This cell is hidden from users, it checks the program executes correctly
from time import sleep
from qiskit import QuantumCircuit

qc = QuantumCircuit(2)
transpile_remote_serverless = serverless.load("transpile_remote_serverless")
job = transpile_remote_serverless.run(
    circuits=[qc],
    backend="ibm_sherbrooke",
    optimization_level=1,
)
while True:
    sleep(5)
    status = job.status()
    if status not in ["QUEUED", "INITIALIZING", "RUNNING", "DONE"]:
        raise Exception(
            f"Unexpected job status: '{status}'\n"
            + "Here are the logs:\n"
            + job.logs()
        )
    if status == "DONE":
        break

Mga susunod na hakbang

Mga rekomendasyon

• Alamin kung paano magpasa ng mga input at patakbuhin ang iyong programa nang remote sa paksa na Patakbuhin ang iyong unang Qiskit Serverless workload nang remote.