Execute uma varredura de parâmetros

Versões dos pacotes

O código desta página foi desenvolvido usando os requisitos a seguir. Recomendamos usar essas versões ou mais recentes.

qiskit-serverless~=0.38.0

Uma varredura de parâmetros funciona como um job array do Slurm. Chame run() uma vez para cada conjunto de entradas, e os jobs executam ao mesmo tempo, cada um em seu próprio nó. Use o mesmo padrão para qualquer lote de entradas independentes, como um job para cada molécula ou cada backend. Os jobs não podem enviar dados uns aos outros, então divida o trabalho em entradas independentes.

Os exemplos desta página usam o workflow de Execute um workflow gerenciado, que lê um ângulo, 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
)

Inicie os jobs

Obtenha o workflow pelo título e chame run() uma vez para cada entrada. Salve os IDs dos jobs em um arquivo: 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)

• Verifique todas as entradas primeiro. Se o workflow tiver um esquema de argumentos, chame validate_arguments() em cada entrada antes do loop.

• Salve os IDs dos jobs em um arquivo. Assim você pode coletar os resultados a partir de uma nova sessão.

• Dê a cada execução nomes de arquivo únicos. Todas as execuções compartilham o armazenamento de arquivos do workflow. Consulte Boa prática: dê nomes únicos aos arquivos de cada execução.

• Fique abaixo do limite de jobs ativos. Um workflow gerenciado não coloca na fila jobs acima do limite, então, quando você o atingir, inicie mais jobs somente depois que os anteriores terminarem.

Colete os resultados

Obtenha cada job pelo ID e capture os jobs que falharam, para que uma falha não interrompa o loop: 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 executar novamente as entradas que falharam, chame run() outra vez com os mesmos argumentos.

Limite de jobs ativos

Você pode ter até 50 jobs na fila, inicializando, em execução ou sendo cancelados ao mesmo tempo. Esse limite conta todos os seus jobs, incluindo os de outros workflows. Se você exceder esse limite, run() gera uma QiskitServerlessException e não cria nem enfileira o job:

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

Próximos passos

Recomendações

• Gerencie arquivos entre execuções para compartilhar arquivos de entrada entre execuções e dar a cada arquivo de execução um nome único.
• Escolha um perfil de computação para executar cada job da varredura em um tamanho compatível com sua entrada.