Início rápido do Estimator

A primitiva Estimator calcula os valores esperados para um ou mais observáveis em relação aos estados preparados por Circuits 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 tem várias técnicas de mitigação e supressão de erros integradas, incluindo desacoplamento dinâmico, Pauli-twirling, ZNE de dobragem de gate, PEA e PEC. Ela também suporta uma opção resilience_level que permite configurar facilmente o trade-off entre custo e precisão. Os passos neste tópico descrevem como configurar o Estimator, explorar as opções que você pode usar para configurá-lo e invocá-lo em um programa.

Nova implementação do Estimator

Novas implementações das interfaces Qiskit SamplerV2 e EstimatorV2 foram introduzidas no qiskit-ibm-runtime v0.50.0. Essas primitivas do lado do cliente realizam a maior parte do pré- e pós-processamento no lado do cliente e delegam a execução à primitiva Executor. Executar no lado do cliente oferece maior transparência, feedback de depuração mais rápido e controle mais refinado.

Como elas implementam a mesma API, essas primitivas do lado do cliente são, em grande parte, substitutas diretas das primitivas legadas do lado do servidor, bastando alterar apenas a instrução de importação. Veja Migrar do Sampler e Estimator do lado do servidor para o lado do cliente para mais informações.

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.5.2
qiskit-ibm-runtime~=0.47.0

Passos para usar a primitiva Estimator

1. Inicializar a conta

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.

Gates fracionários

Para usar os gates fracionários recém-suportados, defina use_fractional_gates=True ao solicitar um Backend de uma instância QiskitRuntimeService. Por exemplo:

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

Esta é uma funcionalidade experimental e pode mudar no futuro.

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"qiskit": "qiskit", "qiskit_ibm_runtime": "qiskit-ibm-runtime"}
_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")

from qiskit_ibm_runtime import QiskitRuntimeService

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

print(backend.name)

ibm_fez

2. Criar um circuito e um observável

Você precisa de pelo menos um circuito e um 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 o observável precisam ser transformados para usar apenas instruções suportadas pela QPU (referidos como circuitos de arquitetura de conjunto de instruções (ISA)). Use o Transpiler para 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()}")

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

3. Inicializar o Estimator do IBM Quantum

Ao inicializar o Estimator, use o parâmetro mode para especificar o modo em que você quer executá-lo. Os valores possíveis são objetos batch, session ou backend para os modos de execução em lote, Session e job, respectivamente. Para mais informações, veja Introdução aos modos de execução do IBM Quantum Compute Service. Note que usuários do Plano Aberto não podem enviar jobs de Session.

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Estimator

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_estimator import Estimator

estimator = Estimator(mode=backend)

4. Invocar o Estimator e obter resultados

Em seguida, invoque o método run() para calcular os valores esperados para os circuitos e observáveis de entrada. O circuito, o observável e os conjuntos opcionais de valores de parâmetros são fornecidos como tuplas de bloco unificado primitivo (PUB).

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

>>> Job ID: dab7lfurrl7c7386gjn0

>>> Job Status: QUEUED

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

>>> 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: 28.60306448415693
  > Metadata: {'shots': 4096, 'target_precision': 0.015625, 'circuit_metadata': {}, 'resilience': {}, 'num_randomizations': 32}

Próximos passos

Recomendações

• Aprenda como testar localmente antes de executar em computadores quânticos.
• Revise exemplos detalhados.
• Pratique com primitivas trabalhando na lição de função de custo no IBM Quantum Learning.
• Aprenda como transpilar localmente na seção Transpilar.
• Experimente o guia Comparar configurações do Transpiler.
• Aprenda como usar as opções das primitivas.
• Veja a API para as opções do Estimator.