Implante seu primeiro workflow gerenciado

Versões dos pacotes

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

qiskit[all]~=2.6.1
qiskit-serverless~=0.38.0

Use esta página para enviar um workflow, executá-lo e obter seu resultado. O workflow de exemplo otimiza e simula um circuito do Qiskit. Ele simula o circuito em hardware clássico, portanto não usa tempo de QPU.

Antes de começar, instale o pacote cliente e autentique-se.

Use habilidades de IA (opcional)

Para implantar seu próprio código com a ajuda de um assistente de IA, use as habilidades de IA do repositório de modelos de Qiskit Function.

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

Escreva um workflow

Crie a estrutura de pastas

Um workflow gerenciado é uma pasta de arquivos Python com um arquivo de ponto de entrada. Um workflow gerenciado envia tudo o que está na pasta, até 50 MB, e executa o ponto de entrada como um script. Como o workflow envia a pasta inteira, mantenha seus arquivos locais, como deploy.ipynb, fora da pasta. Crie o seguinte layout:

hello_world_project/
├── deploy.ipynb         # Your local notebook: upload and run the workflow
└── source_files/         # The working directory that you upload
    └── hello_world.py   # The entrypoint

Escreva o ponto de entrada hello world

O ponto de entrada lê um circuito, o otimiza e o simula, e salva as contagens e a profundidade de dois qubits. Salve o código a seguir como source_files/hello_world.py:

nota

Se você ler esta página como um notebook, a célula de código de hello_world.py começa com o comando mágico %%writefile. Ao executar essa célula, ela salva o código no arquivo em vez de executá-lo.

# 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/hello_world.py
from qiskit.primitives import StatevectorSampler
from qiskit.transpiler import generate_preset_pass_manager
from qiskit_serverless import Job, get_arguments, save_result, update_status

# Read the arguments that you pass to run()
arguments = get_arguments()
circuit = arguments["circuit"]
shots = arguments.get("shots", 1024)

# Optimize the circuit. Printed text goes to the job's logs.
update_status(Job.OPTIMIZING_HARDWARE)
pass_manager = generate_preset_pass_manager(
    optimization_level=1, basis_gates=["cz", "rz", "sx", "x"]
)
isa_circuit = pass_manager.run(circuit)
two_qubit_depth = isa_circuit.depth(lambda instruction: instruction.operation.num_qubits == 2)
print(f"Two-qubit depth after optimization: {two_qubit_depth}", flush=True)

# Simulate the circuit and return the counts
sampler = StatevectorSampler(seed=1234)
pub_result = sampler.run([isa_circuit], shots=shots).result()[0]
save_result({"counts": pub_result.data.meas.get_counts(), "two_qubit_depth": two_qubit_depth})

Writing ./source_files/hello_world.py

O ponto de entrada usa três funções de qiskit_serverless:

• get_arguments() retorna, como um dicionário, os argumentos nomeados que você passa para run(). Cada valor deve ser serializável em JSON ou um objeto que o cliente consiga codificar, como um QuantumCircuit. Os objetos codificados chegam como os mesmos objetos que você passou.

• update_status(Job.OPTIMIZING_HARDWARE) define o status detalhado RUNNING: OPTIMIZING_FOR_HARDWARE, que você pode ver enquanto o job é executado. Consulte Informar o progresso com update_status().

• save_result() armazena um valor serializável em JSON que você lê depois com job.result(). O workflow retorna as contagens como um dicionário e a profundidade de dois qubits do circuito otimizado como um inteiro.

Tudo o que o workflow escreve na saída padrão, como a profundidade de dois qubits, vai para os logs do job. Para adicionar carimbos de data e hora e níveis de log, use o módulo logging. Consulte Escrever logs e tratar erros.

Envie o workflow

No seu notebook local, execute o código a seguir a partir da pasta hello_world_project. O código se conecta com sua conta salva, define o workflow e o envia. entrypoint é o arquivo que o workflow executa, e working_dir é a pasta que você envia:

from qiskit_ibm_catalog import ManagedWorkflow, ManagedWorkflowClient

client = ManagedWorkflowClient()

hello_world = ManagedWorkflow(
    title="hello-world",
    entrypoint="hello_world.py",
    working_dir="./source_files/",
)

hello_world = client.upload(hello_world)

Execute o workflow com entradas

Construa um circuito GHZ de três qubits para passar a hello_world como entrada:

from qiskit import QuantumCircuit

circuit = QuantumCircuit(3)
circuit.h(0)
circuit.cx(0, 1)
circuit.cx(1, 2)
circuit.measure_all()

Execute hello_world com o circuito e o número de shots como argumentos nomeados. Os nomes dos argumentos correspondem às chaves que o ponto de entrada lê com get_arguments():

job = hello_world.run(circuit=circuit, shots=1024)
print(job.job_id)

54705348-5117-44b7-935b-e6986ef182fa

run() retorna um Job depois que o workflow coloca o job na fila. Ele não espera o job ser executado. O job continua na nuvem depois que você fecha sua sessão Python. Para encontrá-lo novamente mais tarde, liste seus jobs recentes com client.jobs().

Obtenha o status, o resultado e os logs

Imediatamente depois de chamar run(), o status geralmente é QUEUED:

job.status()

'QUEUED'

O status muda de QUEUED para INITIALIZING, RUNNING e, em seguida, DONE.

job.result() espera até o job terminar e então retorna o valor que o workflow passou para save_result():

job.result()

{'counts': {'111': 514, '000': 510}, 'two_qubit_depth': 2}

# This cell is hidden from users. It checks the result.
assert set(_["counts"]) <= {"000", "111"}  # noqa: F821
assert sum(_["counts"].values()) == 1024  # noqa: F821

from qiskit.visualization import plot_histogram

plot_histogram(job.result()["counts"])

Você pode ler os logs enquanto o job é executado. O workflow envia novas linhas aproximadamente a cada 15 segundos. Os logs incluem a linha que o workflow imprimiu:

print(job.logs())

Two-qubit depth after optimization: 2

# This cell is hidden from users. It checks the logs.
assert "Two-qubit depth after optimization" in job.logs()

Atualize o workflow

Para alterar um workflow, edite seus arquivos e chame upload() novamente com o mesmo title. O novo envio substitui o anterior, e os jobs que já começaram não são afetados.

Campos como arguments_schema e sizes_map mantêm seus valores armazenados quando você os omite do novo envio.

Próximos passos

Recomendações

• Defina entradas e saídas para saber quais tipos de argumento e de resultado um workflow suporta.
• Declare dependências para usar mais pacotes Python no seu workflow.
• Execute jobs quânticos a partir de um workflow para executar seus circuitos em uma QPU, informar cada etapa e acompanhar os jobs da QPU.
• Execute um workflow gerenciado para conhecer todos os status de job, depurar um job com falha e encontrar um job mais tarde.
• Para começar a partir de um código funcional, implante um dos modelos de Qiskit Function ou adapte um modelo para o seu próprio workflow.