Qiskit Runtime modo de teste local

• Versões do pacote

  O código desta página foi desenvolvido usando os seguintes requisitos. Recomendamos o uso dessas versões ou de versões mais recentes.

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

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

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 ou uma sessão de Qiskit Runtime.

• Backends falsos : Os backends falsos em qiskit_ibm_runtime.fake_provider imitam os comportamentos das QPUs IBM® usando instantâneos de QPUs. Os instantâneos da QPU contêm informações importantes sobre a QPU, como o mapa de acoplamento, as portas de base e as propriedades do qubit, que são úteis para testar o transpilador e realizar simulações com ruído da QPU. O modelo de ruído do instantâneo é aplicado automaticamente durante a simulação.

• Simulador Aer : Os simuladores do Qiskit Aer oferecem simulação de alto desempenho que pode 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 site AerSimulator no modo de teste local. Veja o exemplo do modo de simulação Clifford, que demonstra como simular com eficiência os circuitos Clifford com um grande número de qubits.

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

    Consulte a AerSimulator para obter mais informações.

    • "automatic": Método de simulação padrão. Selecione o método de simulação automaticamente, com base no modelo de circuito e 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 com ruídos, cada disparo coleta uma amostra aleatória de um circuito com ruídos do modelo de ruídos.

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

    • "stabilizer": Um simulador de estado estabilizador de Clifford eficiente que pode simular circuitos de Clifford com ruído se todos os erros no modelo de ruído também forem erros de Clifford.

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

    • "matrix_product_state": Um simulador de vetor de estado de rede tensorial que usa uma representação de estado de produto de matriz (MPS) para o estado. Isso pode ser feito com ou sem truncamento das dimensões do vínculo 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. Esse método só pode simular portas; ele não oferece suporte a medição, redefinição ou ruído.

    • "superop": Uma simulação de matriz de superoperador densa de um circuito ideal ou com ruído. Isso simula a matriz de superoperador do próprio circuito, em vez da evolução de um estado quântico inicial. Esse método pode simular portas e reinicializações ideais e com ruído, mas não oferece suporte a medições.

    • "tensor_network": Uma simulação baseada em rede de tensores que suporta tanto o vetor de estado quanto a matriz de densidade. Atualmente, isso só está disponível para GPU e é acelerado pelo uso das APIs cuQuantum cuTensorNet .

Exemplo de backends falsos

from qiskit.circuit import QuantumCircuit
from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime import SamplerV2 as 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()

AerSimulator exemplos

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, SamplerV2 as 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 cria um modelo de ruído com base nos dados de calibração dessa QPU e instancia um backend do Aer com esse modelo. Se preferir, você pode criar um modelo de ruído.

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 SamplerV2 as Sampler, QiskitRuntimeService

# 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.backend("ibm_fez")
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 de Clifford

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

Exemplo:

import numpy as np
from qiskit.circuit.library import efficient_su2
from qiskit_ibm_runtime import SamplerV2 as 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()

Próximas etapas