Início rápido do Executor

Versões dos pacotes

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

qiskit[all]~=2.4.0
qiskit-ibm-runtime~=0.46.1
samplomatic~=0.18.0

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

Semelhante à primitiva Sampler, o Executor amostra registradores de saída de execuções de circuito quântico, mas não tem supressão ou mitigação de erros integradas. Em vez disso, ele faz parte do modelo de execução direcionada que fornece os ingredientes para capturar intenções de design no lado do cliente e transfere a geração custosa de variantes de circuito para o lado do servidor. O Executor segue as diretivas fornecidas em anotações de circuito e opções, gera e vincula valores de parâmetros, executa os circuitos vinculados no hardware e retorna os resultados de execução e metadados. Ele não toma decisões implícitas por você e oferece controle total e transparência.

nota

O pacote Qiskit ainda não tem uma classe base para a primitiva Executor.

Antes de começar

Alguns dos exemplos de código nesta página usam samplex, que faz parte do pacote Samplomatic. Portanto, antes de executar esses blocos de código, você deve instalar o Samplomatic, conforme mostrado no bloco de código a seguir. Para mais informações, veja a documentação do Samplomatic.

pip install samplomatic

# For visualization support, include the visualization dependencies.
# pip install samplomatic[vis]

Passos para usar a primitiva Executor

1. Inicializar a conta

Como o Qiskit Runtime é um serviço gerenciado, primeiro você precisa inicializar sua conta. Você pode então selecionar a QPU que deseja usar para calcular o valor esperado.

Siga os passos em Configurar sua conta IBM Cloud® se você ainda não tiver uma conta.

from qiskit_ibm_runtime import QiskitRuntimeService, Executor
from qiskit_ibm_runtime.quantum_program import QuantumProgram
from qiskit.circuit import QuantumCircuit
from qiskit.transpiler import generate_preset_pass_manager
from samplomatic.transpiler import generate_boxing_pass_manager
from samplomatic import build

# Initialize the service and choose a backend
service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)

print(backend)

<IBMBackend('ibm_fez')>

2. Criar e transpilar um circuito

Você precisa de pelo menos um circuito para usar a primitiva Executor. Ele pode opcionalmente ter parâmetros.

# Generate the circuit
circuit = QuantumCircuit(2)
circuit.h(0)
circuit.h(1)
circuit.cz(0, 1)
circuit.h(1)

# Using `measure_all` automatically creates the necessary
# classical registers.
circuit.measure_all()

O circuito precisa ser transformado para usar apenas instruções suportadas pela QPU (referido como circuito de arquitetura de conjunto de instruções (ISA)). Use o Transpiler para isso.

# Transpile the circuit
preset_pass_manager = generate_preset_pass_manager(
    backend=backend, optimization_level=0
)
isa_circuit = preset_pass_manager.run(circuit)

3. Inicializar um QuantumProgram

Inicialize um QuantumProgram com sua carga de trabalho. Um QuantumProgram é composto de QuantumProgramItems. Normalmente, cada item consiste em um circuito, um conjunto de valores de parâmetros e possivelmente um samplex para randomizar o conteúdo do circuito. Para detalhes completos, veja Entradas e saídas do Executor.

A célula a seguir inicializa um QuantumProgram e especifica a realização de 25 shots. Em seguida, ele anexa o circuito alvo transpilado.

# Initialize an empty program
program = QuantumProgram(shots=25)

# Append the circuit to the program
program.append_circuit_item(isa_circuit)

4. Opcional: Agrupar gates e medições em caixas anotadas

Agrupar instruções em caixas e anotá-las é a principal forma de especificar sua intenção. No exemplo a seguir, usamos generate_boxing_pass_manager e seus parâmetros de twirling para agrupar gates de dois qubits e medições em caixas e aplicar anotação de twirling.

# Generate a boxing pass manager to group gates
# and measurements into boxes and add
# a`Twirl` annotation.
boxes_pm = generate_boxing_pass_manager(
    # Add gate twirling
    enable_gates=True,
    # Add measurement twirling
    enable_measures=True,
)

boxed_circuit = boxes_pm.run(isa_circuit)
boxed_circuit.draw("mpl", idle_wires=False)

5. Opcional: Construir um circuito modelo e samplex, e adicioná-los ao programa

Em seguida, use o método build do Samplomatic para gerar o par Circuit modelo e samplex. O circuito modelo é estruturalmente equivalente ao Circuit original. No entanto, seus gates de um único qubit são substituídos por gates parametrizados para implementar as anotações prescritas (twirling de gate e medição, neste exemplo). O samplex codifica todas as informações necessárias para gerar parâmetros randomizados para o circuito modelo.

Após gerar o par Circuit modelo e samplex, use o método append_samplex_item para adicionar o par ao programa.

Veja a documentação da API do Samplomatic para detalhes completos sobre samplomatic.samplex.Samplex e seus argumentos.

# Build the template circuit and the samplex
template_circuit, samplex = build(boxed_circuit)

# Append the template circuit and samplex as a `samplex_item`
program.append_samplex_item(
    template_circuit,
    samplex=samplex,
    shape=(num_randomizations := 20,),
)

6. Invocar o Executor e obter resultados

Execute o QuantumProgram em um Backend IBM® usando a primitiva Executor com opções padrão. Veja Opções do Executor para saber sobre as opções disponíveis.

# Initialize an Executor with the default options
executor = Executor(mode=backend)

# Submit the job
job = executor.run(program)
job

<RuntimeJobV2('d8286580bvlc73d1vmsg', 'executor')>

# Retrieve the result
result = job.result()

O resultado é do tipo QuantumProgramResult. Veja Entrada e saída do Executor para saber sobre o objeto resultado.

Próximos passos

Recomendações

• Experimente alguns exemplos do Executor.
• Entenda a entrada e saída do Executor.
• Aprenda sobre a semântica de broadcasting do Executor.