Guia rápido do Executor

• Versões do pacote

  O código desta página foi desenvolvido com base nos seguintes requisitos. Recomendamos o uso dessas versões ou versões mais recentes.

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

Assim como a primitiva Sampler, o Executor coleta amostras dos registros de saída das execuções de circuitos quânticos, mas não possui nenhum mecanismo integrado de supressão ou mitigação de erros. Na verdade, faz parte do modelo de execução direcionada, que fornece os elementos necessários para capturar as intenções do projeto no lado do cliente e transfere a dispendiosa geração de variantes de circuitos para o lado do servidor. O Executor segue as diretrizes fornecidas nas anotações e opções dos circuitos, gera e vincula os valores dos parâmetros, executa os circuitos vinculados no hardware e retorna os resultados da execução e os metadados. Ele não toma nenhuma decisão por você e oferece total controle e transparência.

Antes de iniciar

Alguns dos exemplos de código nesta página utilizam samplex, que faz parte do pacote Samplomatic. Portanto, antes de executar esses blocos de código, é necessário instalar o Samplomatic, conforme mostrado no bloco de código a seguir. Para mais informações, consulte 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, você precisa primeiro configurar sua conta. Em seguida, você pode selecionar a QPU que deseja usar para calcular o valor esperado.

Siga as etapas descritas na seção “Configurar sua conta no IBM Cloud® ” caso ainda não tenha 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)

Output:

<IBMBackend('ibm_fez')>

2. Criar e compilar um circuito

É necessário ter pelo menos um circuito para usar a primitiva Executor. Ela 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 adaptado para utilizar apenas instruções compatíveis com a QPU (conhecidos como circuitos de arquitetura de conjunto de instruções, ou ISA ). Use o transpiler para fazer 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 objeto QuantumProgram

Inicialize um QuantumProgram com sua carga de trabalho. A QuantumProgram é composta por QuantumProgramItems. Normalmente, cada item consiste em um circuito, um conjunto de valores de parâmetros e, eventualmente, um mecanismo samplex para randomizar o conteúdo do circuito. Para obter mais detalhes, consulte Entradas e saídas do Executor.

A célula a seguir inicializa um QuantumProgram e especifica a execução de 25 disparos. Em seguida, ele anexa o circuito de destino compilado.

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

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

4. Opcional: Agrupe portões e medições em caixas anotadas

Agrupar instruções em blocos 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 rotação para agrupar portas de dois qubits e medições em caixas e aplicar a anotação de rotação.

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

Output:

5. Opcional: Crie um circuito modelo e um samplex e adicione-os ao programa

Em seguida, use o método de construção Samplomatic para gerar o circuito modelo e o par de samplex. O circuito modelo é estruturalmente equivalente ao circuito original. No entanto, suas portas de qubit único são substituídas por portas parametrizadas, a fim de implementar as anotações prescritas (rotação de portas e medições, neste exemplo). O samplex codifica todas as informações necessárias para gerar parâmetros aleatórios para o circuito modelo.

Depois de gerar o circuito modelo e o par de amostras, use o append_samplex_item método para adicionar o par ao programa.

Consulte a documentação da API do Samplomatic para obter todos os detalhes 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. Executar o Executor e obter os resultados

Execute o QuantumProgram em um backend do IBM® usando a Executor primitiva com as opções padrão. Consulte as opções do Executor para saber mais 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

Output:

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

# Retrieve the result
result = job.result()

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

Próximas etapas