Modo de teste local

Package versions

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

qiskit[all]~=2.5.2
qiskit-ibm-runtime~=0.47.0
qiskit-aer~=0.17

Use o modo de teste local (disponível no qiskit-ibm-runtime v0.22.0 ou posterior) para testar programas antes de ajustá-los e enviá-los para hardware quântico real. Após usar o modo de teste local para verificar seu programa, tudo que você precisa mudar é o nome do backend para executá-lo em um QPU.

nota

O suporte ao modo local para a primitiva Executor foi introduzido no qiskit-ibm-runtime v0.50.0.

Para usar o modo de teste local, especifique um dos Backends falsos de qiskit_ibm_runtime.fake_provider ou especifique um Backend do Qiskit Aer ao instanciar uma primitiva do IBM Quantum® ou uma Session.

• Backends falsos: Os backends falsos em qiskit_ibm_runtime.fake_provider imitam o comportamento dos QPUs da IBM® usando snapshots de QPU. Os snapshots de QPU contêm informações importantes sobre o QPU, como o mapa de acoplamento, portas de base e propriedades dos qubits, que são úteis para testar o transpilador e realizar simulações ruidosas do QPU. O modelo de ruído do snapshot é aplicado automaticamente durante a simulação.

• Simulador Aer: Os simuladores do Qiskit Aer oferecem simulação de maior desempenho, capaz de lidar com circuitos maiores e modelos de ruído personalizados. Uma lista de opções de métodos de simulação está disponível quando você usa o AerSimulator no modo de teste local. Veja o exemplo do modo de simulação Clifford, que demonstra como simular eficientemente circuitos Clifford com um grande número de qubits.

  Lista de métodos de simulação disponíveis no Qiskit Aer

  Consulte a documentação do AerSimulator para mais informações.

  • "automatic": Método de simulação padrão. Seleciona o método de simulação automaticamente, com base no circuito e no modelo de ruído.

  • "statevector": Uma simulação de vetor de estado denso que pode amostrar resultados de medição de circuitos ideais com todas as medições no final do circuito. Para simulações ruidosas, cada shot amostra aleatoriamente um circuito ruidoso a partir do modelo de ruído.

  • "density_matrix": Uma simulação de matriz densidade que pode amostrar resultados de medição de circuitos ruidosos com todas as medições no final do circuito.

  • "stabilizer": Um simulador eficiente de estado estabilizador Clifford que pode simular circuitos Clifford ruidosos, desde que todos os erros no modelo de ruído também sejam erros Clifford.

  • "extended_stabilizer": Um simulador aproximado para circuitos Clifford + T baseado na decomposição do estado em um estado estabilizador ranqueado. O número de termos cresce com o número de portas não-Clifford (T).

  • "matrix_product_state": Um simulador de vetor de estado em rede tensorial que usa uma representação de Estado Produto Matricial (MPS) para o estado. Isso pode ser feito com ou sem truncamento das dimensões de vínculo do MPS, dependendo das opções do simulador. O comportamento padrão é sem truncamento.

  • "unitary": Uma simulação de matriz unitária densa de um circuito ideal. Isso simula a matriz unitária do próprio circuito, em vez da evolução de um estado quântico inicial. Este método só pode simular portas; não suporta medição, reset ou ruído.

  • "superop": Uma simulação de matriz superoperador densa de um circuito ideal ou ruidoso. Isso simula a matriz superoperador do próprio circuito, em vez da evolução de um estado quântico inicial. Este método pode simular portas e resets ideais e ruidosos, mas não suporta medições.

  • "tensor_network": Uma simulação baseada em rede tensorial que suporta tanto vetor de estado quanto matriz densidade. Atualmente, isso está disponível apenas para GPU e é acelerado com as APIs cuTensorNet do cuQuantum.

Notas

• Você pode especificar todas as opções do IBM Quantum Compute no modo de teste local. Com os Sampler e Estimator do lado do cliente (introduzidos no qiskit-ibm-runtime v0.50.0), as opções de supressão e mitigação de erros são implementadas localmente, de modo que você pode testar diferentes métodos de mitigação de erros localmente antes de comprometer tempo de QPU. Veja Teste a mitigação de erros localmente para um exemplo.

Anteriormente, com as primitivas legadas (do lado do servidor), os simuladores locais ignoravam todas as opções, exceto shots, porque esse processamento ocorria apenas no servidor.

• Recomenda-se instalar o Qiskit Aer antes de usar Backends falsos ou simuladores Aer, executando pip install qiskit-aer. Os Backends falsos usam simuladores Aer internamente, quando disponíveis, para aproveitar seu desempenho.

Exemplo com backends falsos

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

_needed = {"numpy": "numpy", "qiskit": "qiskit", "qiskit_aer": "qiskit-aer", "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.circuit import QuantumCircuit
from qiskit.transpiler import generate_preset_pass_manager

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

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_sampler import Sampler
from qiskit_ibm_runtime.fake_provider import FakeManilaV2

# Bell Circuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

# Run the Sampler job locally using FakeManilaV2
fake_manila = FakeManilaV2()
pm = generate_preset_pass_manager(backend=fake_manila, optimization_level=1)
isa_qc = pm.run(qc)

# You can use a fixed seed to get fixed results.
options = {"simulator": {"seed_simulator": 42}}
sampler = Sampler(mode=fake_manila, options=options)

result = sampler.run([isa_qc]).result()

Exemplos com AerSimulator

Exemplo com sessões, sem ruído:

from qiskit_aer import AerSimulator
from qiskit.circuit import QuantumCircuit
from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime import Session

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

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_sampler import Sampler

# Bell Circuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

# Run the Sampler job locally using AerSimulator.
# Session syntax is supported but ignored because local mode doesn't support sessions.
aer_sim = AerSimulator()
pm = generate_preset_pass_manager(backend=aer_sim, optimization_level=1)
isa_qc = pm.run(qc)
with Session(backend=aer_sim) as session:
    sampler = Sampler(mode=session)
    result = sampler.run([isa_qc]).result()

Para simular com ruído, especifique um QPU (hardware quântico) e envie-o para o Aer. O Aer constrói um modelo de ruído com base nos dados de calibração desse QPU e instancia um backend Aer com esse modelo. Se preferir, você pode construir um modelo de ruído.

cuidado

Um QPU pode ser afetado por diferentes tipos de ruído. O modelo de ruído do Qiskit Aer usado aqui simula apenas alguns deles e, portanto, tende a ser menos severo do que o ruído em um QPU real.

Para detalhes sobre quais erros são incluídos ao inicializar um modelo de ruído a partir de um QPU, consulte a referência da API Aer NoiseModel.

Exemplo com ruído:

from qiskit_aer import AerSimulator
from qiskit.circuit import QuantumCircuit
from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime import QiskitRuntimeService

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

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_sampler import Sampler

# Bell Circuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

service = QiskitRuntimeService()

# Specify a QPU to use for the noise model
real_backend = service.least_busy(operational=True, simulator=False)
aer = AerSimulator.from_backend(real_backend)

# Run the Sampler job locally using AerSimulator.
pm = generate_preset_pass_manager(backend=aer, optimization_level=1)
isa_qc = pm.run(qc)
sampler = Sampler(mode=aer)
result = sampler.run([isa_qc]).result()

Simulação Clifford

Como os circuitos Clifford podem ser simulados eficientemente com resultados verificáveis, a simulação Clifford é uma ferramenta muito útil. Para um exemplo detalhado, consulte Simulação eficiente de circuitos estabilizadores com primitivas do Qiskit Aer.

Exemplo:

import numpy as np
from qiskit.circuit.library import efficient_su2

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

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_sampler import Sampler

n_qubits = 500  # <---- note this uses 500 qubits!
circuit = efficient_su2(n_qubits)
circuit.measure_all()

rng = np.random.default_rng(1234)
params = rng.choice(
    [0, np.pi / 2, np.pi, 3 * np.pi / 2],
    size=circuit.num_parameters,
)

# Tell Aer to use the stabilizer (Clifford) simulation method
aer_sim = AerSimulator(method="stabilizer")

pm = generate_preset_pass_manager(backend=aer_sim, optimization_level=1)
isa_qc = pm.run(qc)
sampler = Sampler(mode=aer_sim)
result = sampler.run([isa_qc]).result()

Teste a mitigação de erros localmente

Com os Sampler e Estimator do lado do cliente (introduzidos no qiskit-ibm-runtime v0.50.0), a supressão e a mitigação de erros acontecem no cliente, e não no servidor. Como resultado, essas opções agora têm efeito no modo de teste local, de modo que você pode experimentar diferentes métodos de mitigação de erros em um Backend falso antes de comprometer tempo de QPU.

nota

Com as primitivas legadas do lado do servidor, definir uma opção como resilience.measure_mitigation em um simulador local não tinha efeito, porque o processamento de mitigação ocorria apenas no servidor. As primitivas do lado do cliente aplicam esse processamento localmente.

Considerações sobre overhead de memória e de tempo de execução

O custo da simulação ruidosa local cresce exponencialmente com o número de qubits, e a maioria dos laptops não consegue simular mais de cerca de 32 qubits. Como os métodos de supressão e mitigação de erros agora são executados localmente, eles adicionam mais overhead de memória e de tempo de execução à simulação básica. Para manter o teste local viável, use uma das seguintes opções:

• Um Backend falso pequeno (como FakeManilaV2, usado abaixo).

• Um simulador sem ruído.

• Simulação Clifford, que escala para um grande número de qubits.

O exemplo a seguir ativa a mitigação de erros de medição com Estimator e o executa em um Backend falso. A opção measure_mitigation = True agora é aplicada localmente aos seus circuitos.

from qiskit.circuit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler import generate_preset_pass_manager

# Legacy server-side primitive before qiskit-ibm-runtime v0.50.0
# from qiskit_ibm_runtime import Estimator

# Client-side primitive introduced in qiskit-ibm-runtime v0.50.0
from qiskit_ibm_runtime.executor_estimator import Estimator
from qiskit_ibm_runtime.fake_provider import FakeManilaV2

# Bell Circuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)

observable = SparsePauliOp("ZZ")

# Transpile the circuit and observable for the fake backend
fake_manila = FakeManilaV2()
pm = generate_preset_pass_manager(backend=fake_manila, optimization_level=1)
isa_qc = pm.run(qc)
isa_observable = observable.apply_layout(isa_qc.layout)

# Run the Estimator job locally using FakeManilaV2
estimator = Estimator(mode=fake_manila)

# With the client-side Estimator, this option takes effect locally
estimator.options.resilience.measure_mitigation = True

result = estimator.run([(isa_qc, isa_observable)]).result()

Próximos passos

Recomendações

• Use a classe Neat para analisar o impacto do ruído em uma carga de trabalho do Estimator.
• Revise exemplos detalhados do Sampler.
• Revise exemplos detalhados do Estimator.
• 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 tutorial Comparar configurações do transpilador.