Lumaktaw sa pangunahing nilalaman

Isulat ang iyong unang Qiskit Serverless na programa

Mga bersyon ng package

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.18.1
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

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-deploy ang iyong programa sa IBM Quantum Platform bilang reusable remote service.

Halimbawa: remote transpilation gamit ang Qiskit Serverless​

Simulan sa sumusunod na halimbawa na nagta-transpile ng isang circuit laban sa isang ibinigay na backend at target na optimization_level, at unti-unting dagdagan ng mas maraming elemento para i-deploy ang iyong workload sa Qiskit Serverless.

Ilagay ang sumusunod na code cell sa file na ./source_files/transpile_remote.py. Ang file na ito ang programa na ia-upload sa Qiskit Serverless.

# Added by doQumentation — required packages for this notebook
!pip install -q qiskit qiskit-ibm-catalog qiskit-ibm-runtime qiskit-serverless
# This cell is hidden from users, it just creates a new folder
from pathlib import Path

Path("./source_files").mkdir(exist_ok=True)
%%writefile ./source_files/transpile_remote.py

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
Writing ./source_files/transpile_remote.py

I-set up ang iyong mga file​

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 source_files para patakbuhin nang remote. Kapag na-set up na ito, maaari mong baguhin ang transpile_remote.py para kumuha ng mga input at magbalik ng mga output.

Kunin ang mga argumento ng programa​

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

%%writefile --append ./source_files/transpile_remote.py

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")
Appending to ./source_files/transpile_remote.py

Sa puntong ito, maaari mong makuha ang iyong backend gamit ang QiskitRuntimeService at idagdag ang iyong umiiral na programa gamit ang sumusunod na code. Kailangan na na-save mo na ang iyong credentials para sa sumusunod na code.

%%writefile --append ./source_files/transpile_remote.py

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
backend = service.backend(backend_name)
Appending to ./source_files/transpile_remote.py

Sa wakas, maaari mong patakbuhin ang transpile_remote() sa lahat ng circuits na ipinasa, at ibalik ang transpiled_circuits bilang resulta:

%%writefile --append ./source_files/transpile_remote.py

results = [
    transpile_remote(circuit, 1, backend)
    for circuit in circuits
]

save_result({
    "transpiled_circuits": results
})
Appending to ./source_files/transpile_remote.py

I-deploy sa IBM Quantum Platform​

Ang nakaraang seksyon ay gumawa ng programa para patakbuhin nang remote. Ang mga code cell sa seksyong ito ay nag-a-upload ng programang iyon sa Qiskit Serverless.

Gamitin ang qiskit-ibm-catalog para mag-authenticate sa QiskitServerless gamit ang iyong API key, na makikita sa IBM Quantum dashboard, at i-upload ang programa.

Maaari mong gamitin ang save_account() para i-save ang iyong credentials (tingnan ang seksyon na I-set up para gamitin ang IBM Cloud). Tandaan na isinusulat nito ang iyong credentials sa parehong file gaya ng QiskitRuntimeService.save_account().

from qiskit_ibm_catalog import QiskitServerless, QiskitFunction

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

Kino-compress ng Qiskit Serverless ang mga nilalaman ng working_dir (sa kasong ito, source_files) sa isang tar, na ini-upload at nilinis pagkatapos. Tinutukoy ng entrypoint ang pangunahing executable na programa para patakbuhin ng Qiskit Serverless. Bukod dito, kung ang iyong programa ay may custom na pip na dependencies, maaari mo itong idagdag sa isang dependencies array:

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)

Para tingnan kung matagumpay na na-upload, gamitin ang serverless.list():

# 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