Guia de introdução rápida ao Estimador

A primitiva Estimator calcula os valores esperados para uma ou mais variáveis observáveis em relação aos estados preparados por circuitos quânticos. Os circuitos podem ser parametrizados, desde que os valores dos parâmetros também sejam fornecidos como entrada para a primitiva.

Esta primitiva possui várias técnicas integradas de mitigação e supressão de erros, incluindo desacoplamento dinâmico, Pauli-twirling, ZNE com gate-folding, PEA e PEC. Ele também oferece uma resilience_level opção que permite configurar facilmente o equilíbrio entre custo e precisão.

As etapas descritas neste tópico explicam como configurar o Estimator, explorar as opções disponíveis para sua configuração e chamá-lo em um programa.

• Versões do pacote

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

  qiskit[all]~=2.5.0
  qiskit-ibm-runtime~=0.47.0
  

Passos para usar a primitiva Estimator

1. Inicializar a conta

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

Siga as etapas descritas na seção “Configurar sua conta do IBM Cloud ” caso ainda não tenha uma conta.

service = QiskitRuntimeService()
fractional_gate_backend = service.least_busy(use_fractional_gates=True)

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
backend = service.least_busy(
    operational=True, simulator=False, min_num_qubits=127
)

print(backend.name)

Output:

ibm_marrakesh

2. Crie um circuito e uma variável observável

Você precisa de pelo menos um circuito e uma variável observável como entradas para a primitiva Estimator.

from qiskit.circuit.library import qaoa_ansatz
from qiskit.quantum_info import SparsePauliOp

entanglement = [tuple(edge) for edge in backend.coupling_map.get_edges()]
observable = SparsePauliOp.from_sparse_list(
    [("ZZ", [i, j], 0.5) for i, j in entanglement],
    num_qubits=backend.num_qubits,
)
circuit = qaoa_ansatz(observable, reps=2)
# The circuit is parametrized, so we will define the parameter values for execution
param_values = [0.1, 0.2, 0.3, 0.4]

O circuito e a variável observável precisam ser transformados para utilizar apenas instruções compatíveis com a QPU (conhecidos como circuitos de arquitetura de conjunto de instruções (ISA) ). Use o transpilador para fazer isso.

from qiskit.transpiler import generate_preset_pass_manager

pm = generate_preset_pass_manager(optimization_level=1, backend=backend)
isa_circuit = pm.run(circuit)
isa_observable = observable.apply_layout(isa_circuit.layout)
print(f">>> Circuit ops (ISA): {isa_circuit.count_ops()}")

Output:

>>> Circuit ops (ISA): OrderedDict([('rz', 4472), ('sx', 1884), ('cz', 1120)])

3. Inicializar o Estimador d Qiskit Runtime

Ao inicializar o Estimator, use o mode parâmetro para especificar o modo em que deseja que ele seja executado. Os valores possíveis backend são batch, session, ou para os modos de execução em lote, sessão e tarefa, respectivamente. Para obter mais informações, consulte a Introdução aos modos de execução do Qiskit Runtime. Observe que os usuários do Open Plan não podem enviar tarefas de sessão.

from qiskit_ibm_runtime import EstimatorV2 as Estimator

estimator = Estimator(mode=backend)

4. Execute o Estimator e obtenha os resultados

Em seguida, chame o run() método para calcular os valores esperados dos circuitos de entrada e das variáveis observáveis. Os conjuntos de valores dos parâmetros de circuito, observáveis e opcionais são inseridos como tuplas de blocos unificados primitivos ( PUB ).

job = estimator.run([(isa_circuit, isa_observable, param_values)])
print(f">>> Job ID: {job.job_id()}")
print(f">>> Job Status: {job.status()}")

Output:

>>> Job ID: d9bjisbv6alc73ct56dg

>>> Job Status: QUEUED

result = job.result()
print(f">>> {result}")
print(f"  > Expectation value: {result[0].data.evs}")
print(f"  > Metadata: {result[0].metadata}")

Output:

>>> PrimitiveResult([PubResult(data=DataBin(evs=np.ndarray(<shape=(), dtype=float64>), stds=np.ndarray(<shape=(), dtype=float64>), ensemble_standard_error=np.ndarray(<shape=(), dtype=float64>)), metadata={'shots': 4096, 'target_precision': 0.015625, 'circuit_metadata': {}, 'resilience': {}, 'num_randomizations': 32})], metadata={'dynamical_decoupling': {'enable': False, 'sequence_type': 'XX', 'extra_slack_distribution': 'middle', 'scheduling_method': 'alap'}, 'twirling': {'enable_gates': False, 'enable_measure': True, 'num_randomizations': 'auto', 'shots_per_randomization': 'auto', 'interleave_randomizations': True, 'strategy': 'active-accum'}, 'resilience': {'measure_mitigation': True, 'zne_mitigation': False, 'pec_mitigation': False}, 'version': 2})
  > Expectation value: 24.052015949594512
  > Metadata: {'shots': 4096, 'target_precision': 0.015625, 'circuit_metadata': {}, 'resilience': {}, 'num_randomizations': 32}

Próximas etapas