Pular para o conteúdo principal

Migrar de simuladores em nuvem para simuladores locais

Na computação quântica, a escolha entre usar simuladores e hardware quântico é crucial para avançar na área. Embora os simuladores sejam úteis para testes e depuração, nessa era de utilidade quântica, o desenvolvimento quântico e o avanço da indústria requerem hardware real. Como parte da transição para a utilidade quântica, os simuladores em nuvem do IBM Quantum® foram descontinuados em 15 de maio de 2024. Este guia explica a descontinuação com mais detalhes e mostra como migrar de simuladores em nuvem, como o ibmq_qasm_simulator, para simuladores locais.

Por que os simuladores em nuvem estão sendo descontinuados?​

Os simuladores em nuvem estão sendo descontinuados por vários motivos:

Simuladores têm limitações

Os simuladores podem ser úteis, mas são limitados demais para uso em pesquisa ou experimentação:

  • Os simuladores são valiosos para entender QPUs (unidades de processamento quântico) em pequena escala, mas sua utilidade chega ao limite em torno de 50 qubits, mesmo com acesso a supercomputadores de alto desempenho. Esse teto decorre do crescimento exponencial nos recursos computacionais necessários para simular computadores quânticos maiores (consulte Massively parallel quantum computer simulator, eleven years later para a explicação completa). Explorar computadores quânticos de 100 qubits ou mais requer hardware.

  • Embora alguns simuladores ofereçam modelos de ruído, é muito difícil capturar toda a dinâmica de uma QPU real. O hardware quântico oferece aos pesquisadores a possibilidade de enfrentar os desafios inerentes aos computadores quânticos — como ruído, erros e decoerência — em um ambiente de teste realista.

Usar hardware quântico desenvolve habilidades únicas

Interagir com hardware quântico desenvolve habilidades e experiências inatingíveis usando apenas simuladores:

  • A interação direta com hardware quântico desenvolve habilidades porque você precisa implementar ou usar técnicas de mitigação ou supressão de erros para obter computação confiável.

  • A experiência prática com hardware quântico proporciona uma compreensão mais profunda dos fenômenos quânticos e de como adaptar algoritmos às características dos processadores quânticos.

  • Trabalhar com hardware quântico gera insights práticos sobre os desafios e as oportunidades da computação quântica, aprimorando a capacidade dos desenvolvedores de impulsionar a inovação na área.

Algoritmos devem ser adaptados para hardware quântico

Algoritmos quânticos bem-sucedidos precisam ser adaptados para explorar as capacidades do hardware quântico, otimizando desempenho e eficiência.

  • O hardware quântico oferece uma representação mais precisa das QPUs do mundo real do que os simuladores.

  • O ajuste fino de algoritmos para hardware quântico envolve a modificação do ansatz, das implementações de circuitos, dos parâmetros e da configuração para maximizar o desempenho. Esse processo é melhor alcançado por meio de experimentação direta com hardware quântico.

Quando os simuladores devem ser usados?​

Os simuladores quânticos devem ser usados para ajudar a desenvolver e testar programas antes de refiná-los e enviá-los ao hardware quântico. Os simuladores locais conseguem fazer isso com bom desempenho e eficiência. Circuitos Clifford podem ser simulados de forma muito eficiente e os resultados podem ser verificados, o que é uma maneira útil de ganhar confiança em um experimento.

nota

O modo de teste local não possui supressão ou mitigação de erros integrada. Em vez disso, você deve especificar essas opções explicitamente. Consulte Configurar mitigação de erros para o Qiskit Runtime para mais detalhes.

Migrar para simuladores locais​

Com o qiskit-ibm-runtime 0.22.0 ou posterior, você pode usar o modo de teste local para substituir os simuladores em nuvem. Dependendo das suas necessidades, há várias formas de usar o modo de teste local. Para começar, especifique um dos fake backends em qiskit_ibm_runtime.fake_provider ou especifique um backend do Qiskit Aer ao instanciar um primitivo ou uma sessão.

Orientação para escolher um simulador​

Use a tabela a seguir para ajudar a escolher um simulador.

SimuladorFake BackendsAerSimulatorSimulação Clifford
FinalidadeImita QPUs específicas da IBM® usando snapshotsSimulação de propósito geral e alto desempenhoSimulação eficiente para circuitos Clifford
Modelo de ruídoAplica automaticamente o modelo de ruído dos snapshots da QPUPersonalizado ou baseado em dados de calibração de QPU realIdeal para simulações sem ruído
Tamanho do circuitoLimitado às capacidades da QPU imitadaCapaz de lidar com circuitos maioresAdequado para circuitos muito grandes (centenas de qubits)
ResultadosTempo de execução moderado para testes específicos de QPUTempo de execução menor para uma ampla variedade de simulaçõesExtremamente rápido, adequado para circuitos estabilizadores
Caso de usoTeste do transpiler e comportamento específico de QPUDesenvolvimento geral, modelos de ruído personalizadosCircuitos estabilizadores grandes, correção de erros
nota

Para a maioria dos usuários, o AerSimulator é uma boa escolha, devido à sua flexibilidade e desempenho. No entanto, se o seu trabalho tem como alvo uma QPU específica, um fake backend pode ser uma escolha melhor.

Fake backends​

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

Exemplo:

from qiskit.circuit.library import RealAmplitudes
from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime.fake_provider import FakeManilaV2
from qiskit_ibm_runtime import SamplerV2 as Sampler, QiskitRuntimeService

service = QiskitRuntimeService()

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

Você pode usar o modo de teste local com simuladores do Qiskit Aer, que oferece simulação de maior desempenho, capaz de lidar com circuitos maiores e modelos de ruído personalizados. Ele também suporta o modo de simulação Clifford, que pode simular eficientemente circuitos Clifford com um grande número de qubits.

Exemplo com sessões, sem ruído:

cuidado

O bloco de código a seguir retornará um erro para usuários do Plano Open, pois utiliza sessões. Cargas de trabalho no Plano Open só podem ser executadas em modo job ou modo batch.

from qiskit_aer import AerSimulator
from qiskit.circuit.library import RealAmplitudes
from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime import Session, SamplerV2 as Sampler, QiskitRuntimeService

service = QiskitRuntimeService()

# 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()
    result = sampler.run([isa_qc]).result()

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

Exemplo com ruído:

from qiskit_aer import AerSimulator
from qiskit.circuit.library import RealAmplitudes
from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler

service = QiskitRuntimeService()

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

# Specify a QPU to use for the noise model
real_backend = service.backend("ibm_brisbane")
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 primitivos do Qiskit Aer.

Exemplo:

import numpy as np
from qiskit.circuit.library import EfficientSU2
from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler

service = QiskitRuntimeService()

n_qubits = 500  # <---- note this uses 500 qubits!
circuit = EfficientSU2(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_circuit = pm.run(circuit)
sampler = Sampler(mode=aer_sim)
result = sampler.run([(isa_circuit, params)]).result()