Migrar de simuladores en la nube a simuladores locales
En la computación cuántica, la elección entre usar simuladores y hardware cuántico real es fundamental para avanzar en el campo. Si bien los simuladores son útiles para probar y depurar, en esta era de utilidad cuántica, el desarrollo cuántico y el avance de la industria requieren hardware real. Como parte de la transición hacia la utilidad cuántica, los simuladores en la nube de IBM Quantum® fueron retirados el 15 de mayo de 2024. Esta guía explica el retiro con más detalle y cómo migrar desde simuladores basados en la nube, como ibmq_qasm_simulator, a simuladores locales.
¿Por qué se están retirando los simuladores en la nube?
Los simuladores en la nube se están retirando por varias razones:
Los simuladores tienen limitaciones
Los simuladores pueden ser útiles, pero son demasiado limitados para usarlos en investigación o experimentación:
-
Los simuladores son valiosos para comprender QPUs (unidades de procesamiento cuántico) a pequeña escala, pero su utilidad tiene un techo de alrededor de 50 qubits, incluso con acceso a supercomputadoras de alto rendimiento. Este límite proviene del crecimiento exponencial en los recursos computacionales necesarios para simular computadoras cuánticas más grandes (consulta Massively parallel quantum computer simulator, eleven years later para la explicación completa). Explorar computadoras cuánticas de 100 qubits o más requiere hardware real.
-
Si bien algunos simuladores ofrecen modelos de ruido, capturar toda la dinámica de una QPU real es un problema muy difícil. El hardware cuántico ofrece a los investigadores la posibilidad de enfrentar los desafíos inherentes a las computadoras cuánticas, como el ruido, los errores y la decoherencia, en un entorno de prueba realista.
Usar hardware cuántico desarrolla habilidades únicas
Interactuar con hardware cuántico desarrolla habilidades y experiencia que no se pueden adquirir usando solo simuladores:
-
La interacción directa con hardware cuántico desarrolla habilidades porque debes implementar o usar técnicas de mitigación o supresión de errores para lograr una computación confiable.
-
La experiencia práctica con hardware cuántico desarrolla una comprensión más profunda de los fenómenos cuánticos y de cómo adaptar los algoritmos a las características de los procesadores cuánticos.
-
Trabajar con hardware cuántico genera perspectivas prácticas sobre los desafíos y oportunidades de la computación cuántica, mejorando la capacidad de los desarrolladores para impulsar la innovación en el campo.
Los algoritmos deben adaptarse al hardware cuántico
Los algoritmos cuánticos exitosos deben adaptarse para aprovechar las capacidades del hardware cuántico, optimizando el rendimiento y la eficiencia.
-
El hardware cuántico proporciona una representación más precisa de las QPUs del mundo real que los simuladores.
-
Ajustar con precisión los algoritmos para el hardware cuántico implica modificar el ansatz, las implementaciones del Circuit, los parámetros y la configuración para maximizar el rendimiento. Este proceso se logra mejor mediante la experimentación directa con hardware cuántico.
¿Cuándo se deben usar los simuladores?
Los simuladores cuánticos deben usarse para ayudar a desarrollar y probar programas antes de ajustarlos con precisión y enviarlos al hardware cuántico. Los simuladores locales pueden hacer esto con buen rendimiento y eficiencia. Los Clifford circuits se pueden simular de forma muy eficiente y los resultados se pueden verificar, lo cual es una forma útil de ganar confianza en un experimento.
El modo de prueba local no tiene supresión ni mitigación de errores incorporadas. En su lugar, debes especificar esas opciones de forma explícita. Consulta Configurar la mitigación de errores para Qiskit Runtime para más detalles.
Migrar a simuladores locales
Con qiskit-ibm-runtime 0.22.0 o posterior, puedes usar el modo de prueba local para reemplazar los simuladores en la nube. Según tus necesidades, hay varias formas de usar el modo de prueba local. Para comenzar, especifica uno de los fake backends en qiskit_ibm_runtime.fake_provider o especifica un Backend de Qiskit Aer al instanciar un primitivo o una sesión.
Orientación para elegir un simulador
Usa la siguiente tabla para ayudarte a elegir un simulador.
| Simulador | Fake Backends | AerSimulator | Simulación Clifford |
|---|---|---|---|
| Propósito | Imita QPUs específicas de IBM® usando instantáneas | Simulación de propósito general y alto rendimiento | Simulación eficiente para Clifford circuits |
| Modelo de ruido | Aplica automáticamente el modelo de ruido de las instantáneas de QPU | Personalizado o basado en datos de calibración de QPU real | Ideal para simulaciones sin ruido |
| Tamaño del Circuit | Limitado a las capacidades de la QPU imitada | Puede manejar circuits más grandes | Adecuado para circuits muy grandes (cientos de qubits) |
| Resultados | Tiempo de ejecución moderado para pruebas específicas de QPU | Menor tiempo de ejecución para una amplia gama de simulaciones | Extremadamente rápido, adecuado para stabilizer circuits |
| Caso de uso | Probar el Transpiler y el comportamiento específico de la QPU | Desarrollo general, modelos de ruido personalizados | Grandes stabilizer circuits, corrección de errores |
Para la mayoría de los usuarios, AerSimulator es una buena opción, por su flexibilidad y rendimiento. Sin embargo, si tu trabajo apunta a una QPU específica, un fake backend podría ser una mejor opción.
Fake backends
Los fake backends imitan el comportamiento de las QPUs de IBM usando instantáneas. Las instantáneas contienen información importante sobre la QPU, como el mapa de acoplamiento, las gates base y las propiedades de los qubits, que son útiles para probar el Transpiler y realizar simulaciones con ruido de la QPU. El modelo de ruido de la instantánea se aplica automáticamente durante la simulación.
Ejemplo:
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
Puedes usar el modo de prueba local con simuladores de Qiskit Aer, que proporciona simulación de mayor rendimiento capaz de manejar circuits más grandes y modelos de ruido personalizados. También admite el modo de simulación Clifford, que puede simular eficientemente Clifford circuits con un gran número de qubits.
Ejemplo con sesiones, sin ruido:
El siguiente bloque de código devolverá un error para los usuarios del Plan Abierto, porque usa sesiones. Las cargas de trabajo en el Plan Abierto solo pueden ejecutarse en modo job o en 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 con ruido, especifica una QPU (hardware cuántico) y envíala a Aer. Aer construye un modelo de ruido basado en los datos de calibración de esa QPU e instancia un Backend de Aer con ese modelo. Si lo prefieres, puedes construir un modelo de ruido.
Ejemplo con ruido:
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()
Simulación Clifford
Dado que los Clifford circuits pueden simularse de forma eficiente con resultados verificables, la simulación Clifford es una herramienta muy útil. Para ver un ejemplo detallado, consulta Simulación eficiente de stabilizer circuits con primitivos de Qiskit Aer.
Ejemplo:
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()