Napiš svůj první program Qiskit Serverless

Verze balíčků

Kód na této stránce byl vyvinut s využitím následujících závislostí. Doporučujeme používat tyto verze nebo novější.

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

tip

Qiskit Serverless prochází upgradem a jeho funkce se rychle mění. Během této vývojové fáze najdeš poznámky k vydání a nejnovější dokumentaci na stránce Qiskit Serverless GitHub.

Tento příklad ukazuje, jak pomocí nástrojů qiskit-serverless vytvořit program pro paralelní transpilaci, a následně implementovat qiskit-ibm-catalog pro nahrání tvého programu na IBM Quantum Platform jako opakovaně použitelnou vzdálenou službu.

Přehled pracovního postupu

1. Vytvoř lokální adresář a prázdný soubor programu (./source_files/transpile_remote.py)
2. Přidej do svého programu kód, který po nahrání do Qiskit Serverless transpiluje circuit
3. Použij qiskit-ibm-catalog pro ověření v Qiskit Serverless
4. Nahraj program do Qiskit Serverless

Po nahrání programu ho můžeš spustit k transpilaci circuitu podle průvodce Spusť svou první zátěž Qiskit Serverless vzdáleně.

# Added by doQumentation — required packages for this notebook
!pip install -q qiskit qiskit-ibm-catalog qiskit-ibm-runtime qiskit-serverless

Příklad: Vzdálená transpilace s Qiskit Serverless

Tento příklad tě provede vytvořením a doplňováním souboru programu, který po nahrání do Qiskit Serverless transpiluje circuit pro zadaný backend a cílový optimization_level.

tip

Qiskit Serverless vyžaduje uspořádání .py souborů tvé zátěže do vyhrazeného adresáře. Následující struktura je příkladem dobré praxe:

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

Serverless nahraje obsah konkrétního adresáře (v tomto příkladu adresáře source_files) ke vzdálenému spuštění. Jakmile jsou tyto soubory nastaveny, můžeš upravit transpile_remote.py tak, aby načítal vstupní hodnoty a vracel výstupy.

Vytvoření adresáře a prázdného souboru programu

Nejprve vytvoř adresář s názvem source_files a poté v něm vytvoř soubor programu tak, aby jeho cesta byla ./source_files/transpile_remote.py. Tento soubor nahraješ do Qiskit Serverless.

Přidání kódu do souboru programu

Naplň soubor programu následujícím kódem a ulož ho.

pozor

Pokud čteš buňky kódu lokálně v notebooku, uvidíš magický příkaz %%writefile. Spuštění buněk s tímto magickým příkazem je uloží na disk místo jejich spuštění.

# 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

Přidání kódu pro získání argumentů programu

Nyní přidej do souboru programu následující kód, který nastavuje argumenty programu.

Tvůj počáteční soubor transpile_remote.py má tři vstupy: circuits, backend_name a optimization_level. Serverless je v současnosti omezen pouze na serializovatelné vstupy a výstupy. Z tohoto důvodu nelze předat backend přímo, takže místo toho použij backend_name jako řetězec.

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

Přidání kódu volajícího backend

Přidej do souboru programu následující kód, který volá tvůj backend pomocí QiskitRuntimeService.

Následující kód předpokládá, že sis již prošel procesem uložení přihlašovacích údajů pomocí QiskitRuntimeService.save_account, a načte tvůj výchozí uložený účet, pokud neurčíš jinak. Více informací najdeš v průvodcích Ulož své přihlašovací údaje a Inicializuj svůj účet služby Qiskit Runtime.

%%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_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
backend = service.backend(backend_name)

Přidání kódu pro transpilaci

Nakonec přidej do souboru programu následující kód. Tento kód spustí transpile_remote() pro všechny předané circuits a vrátí transpiled_circuits jako výsledek:

%%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
})

Ověření v Qiskit Serverless

Použij qiskit-ibm-catalog pro ověření v QiskitServerless pomocí svého API klíče (můžeš použít svůj API klíč pro QiskitRuntimeService, nebo si vytvořit nový API klíč na IBM Quantum Platform dashboardu).

from qiskit_ibm_catalog import QiskitServerless, QiskitFunction

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

Spuštění kódu pro nahrání

Spusť následující kód pro nahrání programu. Qiskit Serverless zkomprimuje obsah working_dir (v tomto případě source_files) do souboru tar, který se nahraje a poté vyčistí. Parametr entrypoint identifikuje hlavní spustitelný soubor programu, který má Qiskit Serverless spustit.

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)

Ověření nahrání

Chceš-li ověřit, zda se nahrání zdařilo, použij serverless.list(), jak ukazuje následující kód:

# 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

Další kroky

Doporučení

• Zjisti, jak předávat vstupy a spouštět svůj program vzdáleně, v tématu Spusť svou první zátěž Qiskit Serverless vzdáleně.