Magpatakbo ng parameter sweep

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-serverless~=0.38.0

Ang parameter sweep ay gumagana tulad ng Slurm job array. Tawagin ang run() nang isang beses para sa bawat set ng input, at sabay-sabay na tatakbo ang mga job, bawat isa sa sarili nitong node. Gamitin ang parehong pattern para sa anumang batch ng mga independent na input, tulad ng isang job para sa bawat molecule o bawat backend. Hindi makakapagpadala ng data sa isa't isa ang mga job, kaya hatiin ang trabaho sa mga independent na input.

Ang mga halimbawa sa pahinang ito ay gumagamit ng workflow mula sa Run a managed workflow, na nagbabasa ng isang anggulo, theta:

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

_needed = {"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")

# 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
import math

from qiskit_serverless import get_arguments, save_result

arguments = get_arguments()
theta = arguments["theta"]
if not 0 <= theta <= math.pi:
    raise ValueError(f"theta must be between 0 and pi, got {theta}")

print(f"Computing the expectation value for theta={theta}", flush=True)
save_result({"theta": theta, "expectation_value": math.cos(theta)})

Writing ./source_files/my_workflow.py

# This cell is hidden from users. It uploads the workflow under a title that
# other test notebooks do not use, and makes load("my-workflow") return it.
import logging

from qiskit_ibm_catalog import ManagedWorkflow, ManagedWorkflowClient

logging.getLogger("qiskit_ibm_runtime").setLevel(logging.ERROR)

_test_title = "docs-run-parameter-sweep"
ManagedWorkflowClient().upload(
    ManagedWorkflow(
        title=_test_title,
        entrypoint="my_workflow.py",
        working_dir="./source_files/",
    )
)
_load = ManagedWorkflowClient.load
ManagedWorkflowClient.load = lambda self, title, *a, **k: _load(
    self, _test_title if title == "my-workflow" else title, *a, **k
)

Simulan ang mga job

Kunin ang workflow gamit ang title nito, at tawagin ang run() nang isang beses para sa bawat input. I-save ang mga job ID sa isang file: run_workflow_remotely.ipynb

import json

from qiskit_ibm_catalog import ManagedWorkflowClient

client = ManagedWorkflowClient()
my_workflow = client.load("my-workflow")

thetas = [0.1, 0.2, 0.3]

job_ids = {
    f"theta-{theta}": my_workflow.run(theta=theta).job_id for theta in thetas
}

with open("job_ids.json", "w") as f:
    json.dump(job_ids, f)

• Suriin muna ang bawat input. Kung may argument schema ang workflow, tawagin ang validate_arguments() sa bawat input bago ang loop.

• I-save ang mga job ID sa isang file. Makokolekta mo na ang mga resulta mula sa bagong session.

• Bigyan ng natatanging pangalan ang mga file ng bawat run. Nagbabahagi ang lahat ng run ng file storage ng workflow. Tingnan ang Best practice: give each run's files a unique name.

• Manatili sa ilalim ng active job limit. Hindi nagq-queue ng mga job na lampas sa limit ang managed workflow, kaya kapag naabot mo ito, magsimula ng mas marami pang job pagkatapos lang matapos ang mga naunang job.

Kolektahin ang mga resulta

Kunin ang bawat job gamit ang ID nito, at saluhin ang mga pumalyang job para hindi huminto ang loop dahil sa isang pagkabigo: run_workflow_remotely.ipynb

from qiskit_serverless.exception import QiskitServerlessException

with open("job_ids.json") as f:
    job_ids = json.load(f)

results, errors = {}, {}
for run_name, sweep_job_id in job_ids.items():
    try:
        results[run_name] = client.job(sweep_job_id).result()
    except QiskitServerlessException as error:
        errors[run_name] = str(error)

print(f"{len(results)} jobs finished, {len(errors)} failed")

3 jobs finished, 0 failed

# This cell is hidden from users. It checks the sweep results.
assert len(results) == 3 and not errors, (results, errors)
assert all(results[f"theta-{t}"]["theta"] == t for t in thetas)

Para patakbuhin ulit ang mga input na pumalya, tawagin ulit ang run() gamit ang parehong mga argumento.

Limitasyon sa aktibong job

Maaari kang magkaroon ng hanggang 50 job na naka-queue, nag-i-initialize, tumatakbo, o kinakansela nang sabay-sabay. Binibilang ng limitasyong ito ang lahat ng job mo, kasama ang mga job ng ibang workflow. Kapag lumampas ka sa limitasyong ito, nagtataas ang run() ng QiskitServerlessException at hindi gumagawa o nagku-queue ng job:

| Message: Http bad request.
| Code: 429
| Details: Active job limit reached. The maximum allowed is 50.

Mga susunod na hakbang

Mga rekomendasyon

• Pamahalaan ang mga file sa iba't ibang run para magbahagi ng mga input file sa pagitan ng mga run at bigyan ng natatanging pangalan ang mga file ng bawat run.
• Pumili ng compute profile para patakbuhin ang bawat job ng sweep sa laking tugma sa input nito.