Escreva seu primeiro programa em Qiskit Serverless

• Versões do pacote

  O código desta página foi desenvolvido usando os seguintes requisitos. Recomendamos o uso dessas versões ou de versões mais recentes.

  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
  

Este exemplo demonstra como usar qiskit-serverless ferramentas para criar um programa de transpilagem paralela e, em seguida, implementá-lo qiskit-ibm-catalog para enviar seu programa para IBM Quantum Platform, a fim de utilizá-lo como um serviço remoto reutilizável.

Visão Geral do Fluxo de Trabalho

1. Crie um diretório local e um arquivo de programa vazio (./source_files/transpile_remote.py)
2. Adicione código ao seu programa que, quando enviado para Qiskit Serverless, irá transpilar um circuito
3. Use qiskit-ibm-catalog para autenticar em Qiskit Serverless
4. Envie o programa para Qiskit Serverless

Depois de enviar seu programa, você pode executá-lo para transpilar o circuito seguindo o guia “Execute remotamente sua primeira carga de trabalho do Qiskit Serverless ”.

Exemplo: Transpilagem remota com Qiskit Serverless

Este exemplo mostra como criar e adicionar conteúdo a um arquivo de programa que, quando enviado para Qiskit Serverless, irá transpilar um circuit em relação a um determinado backend e direcionar para optimization_level.

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

O Serverless carrega o conteúdo de um diretório específico (neste exemplo, o source_files diretório) para ser executado remotamente. Depois de configurá-los, você pode ajustá-los transpile_remote.py para obter entradas e retornar saídas.

Crie o diretório e um arquivo de programa vazio

Primeiro, crie uma pasta chamada source_files, depois crie um arquivo de programa nessa pasta, de modo que seu caminho seja ./source_files/transpile_remote.py. Este é o arquivo que você deverá enviar para Qiskit Serverless.

Adicione código ao seu arquivo de programa

Insira o código a seguir no seu arquivo de programa e salve-o.

# This cell is hidden from users, it creates a new folder
from pathlib import Path

Path("./source_files").mkdir(exist_ok=True)

# 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

Adicione código para obter os argumentos do programa

Agora adicione o código a seguir ao seu arquivo de programa, que configura os argumentos do programa.

Seu site inicial transpile_remote.py tem três entradas: circuits, backend_name, e optimization_level. Atualmente, o Serverless está limitado a aceitar apenas entradas e saídas serializáveis. Por esse motivo, você não pode passar o endereço backend diretamente, portanto, use backend_name como uma cadeia de caracteres.

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

Adicione o código que chama o backend

Adicione o seguinte código ao seu arquivo de programa, que chama seu backend com QiskitRuntimeService.

O código a seguir pressupõe que você já seguiu o processo para salvar suas credenciais usando QiskitRuntimeService.save_accounte carregará sua conta salva padrão, a menos que você especifique o contrário. Consulte Salvar suas credenciais de login e Inicializar sua conta de serviço Qiskit Runtime para obter mais informações.

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

Adicionar código para compilação

Por fim, adicione o código a seguir ao seu arquivo de programa. Este código é executado transpile_remote() em todos os valores circuits passados e retorna o transpiled_circuits resultado:

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

Faça a autenticação em Qiskit Serverless

Use qiskit-ibm-catalog para se autenticar no QiskitServerless com sua chave de API (você pode usar sua chave QiskitRuntimeService de API ou criar uma nova chave de API no painel do IBM Quantum Platform ).

from qiskit_ibm_catalog import QiskitServerless, QiskitFunction

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

Execute o código para fazer o upload

Execute o código a seguir para fazer o upload do programa. Qiskit Serverless compacta o conteúdo de working_dir (neste caso, source_files) em um tar, que é enviado e, em seguida, eliminado. O entrypoint identifica o executável principal do programa para que o Qiskit Serverless seja executado.

transpile_remote_demo = QiskitFunction(
    title="transpile_remote_serverless",
    entrypoint="transpile_remote.py",
    working_dir="./source_files/",
)

serverless.upload(transpile_remote_demo)

Output:

QiskitFunction(transpile_remote_serverless)

Verificar upload

Para verificar se o upload foi realizado com sucesso, use serverless.list(), conforme mostrado no código a seguir:

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

Output:

QiskitFunction(transpile_remote_serverless)

Próximas etapas