Saltar al contenido principal
Este proyecto está en fase beta. ¿Encontraste un error? Abre un issue en GitHub. ¿Tienes una pregunta o una idea? Pregunta en Discussions — ¡nos encantaría tu opinión!
¿Cómo es la calidad de la traducción en esta página?

Modo de prueba local

Versiones de paquetes

El código de esta página fue desarrollado con los siguientes requisitos. Recomendamos usar estas versiones o versiones más recientes.

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

Usa el modo de prueba local (disponible con qiskit-ibm-runtime v0.22.0 o posterior) para probar programas antes de ajustarlos y enviarlos a hardware cuántico real. Después de usar el modo de prueba local para verificar tu programa, lo único que necesitas cambiar es el nombre del backend para ejecutarlo en una QPU.

nota

La compatibilidad con el modo local para la primitiva Executor se introdujo en qiskit-ibm-runtime v0.50.0.

Para usar el modo de prueba local, especifica uno de los fake backends de qiskit_ibm_runtime.fake_provider o especifica un backend de Qiskit Aer al instanciar una primitiva de IBM Quantum® o una sesión.

  • Fake backends: Los fake backends en qiskit_ibm_runtime.fake_provider imitan el comportamiento de las QPUs de IBM® mediante el uso de instantáneas de QPU. Las instantáneas de QPU contienen información importante sobre la QPU, como el mapa de acoplamiento, las gates de 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.

  • Simulador Aer: Los simuladores de Qiskit Aer ofrecen simulación de mayor rendimiento, capaz de manejar Circuits más grandes y modelos de ruido personalizados. Cuando usas AerSimulator en el modo de prueba local, tienes disponible una lista de opciones de métodos de simulación. Consulta el ejemplo del modo de simulación Clifford, que demuestra cómo simular eficientemente Circuits de Clifford con un gran número de qubits.

    Lista de métodos de simulación disponibles en Qiskit Aer

    Consulta la documentación de AerSimulator para más información.

    • "automatic": Método de simulación predeterminado. Selecciona el método de simulación automáticamente según el circuito y el modelo de ruido.

    • "statevector": Una simulación de vector de estado denso que puede muestrear resultados de medición de Circuits ideales con todas las mediciones al final del circuito. En simulaciones con ruido, cada shot muestrea un circuito ruidoso seleccionado aleatoriamente del modelo de ruido.

    • "density_matrix": Una simulación de matriz de densidad que puede muestrear resultados de medición de Circuits ruidosos con todas las mediciones al final del circuito.

    • "stabilizer": Un simulador eficiente de estados estabilizadores de Clifford que puede simular Circuits de Clifford con ruido si todos los errores en el modelo de ruido también son errores de Clifford.

    • "extended_stabilizer": Un simulador aproximado para Circuits de Clifford + T basado en descomponer el estado en un estado estabilizador de rango. El número de términos crece con el número de gates no-Clifford (T).

    • "matrix_product_state": Un simulador de vector de estado en red tensorial que usa una representación de estado de producto de matrices (MPS) para el estado. Esto puede hacerse con o sin truncar las dimensiones de enlace del MPS, según las opciones del simulador. El comportamiento predeterminado es sin truncamiento.

    • "unitary": Una simulación de matriz unitaria densa de un circuito ideal. Simula la matriz unitaria del circuito en sí, en lugar de la evolución de un estado cuántico inicial. Este método solo puede simular gates; no admite medición, reinicio ni ruido.

    • "superop": Una simulación de matriz de superoperador densa de un circuito ideal o ruidoso. Simula la matriz de superoperador del circuito en sí, en lugar de la evolución de un estado cuántico inicial. Este método puede simular gates y reinicios ideales y ruidosos, pero no admite mediciones.

    • "tensor_network": Una simulación basada en redes tensoriales que admite tanto vector de estado como matriz de densidad. Actualmente solo está disponible para GPU y se acelera usando las APIs cuTensorNet de cuQuantum.

Notas
  • Puedes especificar todas las opciones de IBM Quantum Compute en el modo de prueba local. Con los Sampler y Estimator del lado del cliente (introducidos en qiskit-ibm-runtime v0.50.0), las opciones de supresión y mitigación de errores se implementan localmente, por lo que puedes probar distintos métodos de mitigación de errores de forma local antes de consumir tiempo de QPU. Consulta Probar la mitigación de errores localmente para ver un ejemplo.

Anteriormente, con las primitivas heredadas (del lado del servidor), los simuladores locales ignoraban todas las opciones excepto shots, porque ese procesamiento solo ocurría en el servidor.

  • Se recomienda instalar Qiskit Aer antes de usar fake backends o simuladores Aer ejecutando pip install qiskit-aer. Los fake backends usan simuladores Aer internamente cuando están disponibles, para aprovechar su rendimiento.

Ejemplo con fake backends​

# 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()

Ejemplos con AerSimulator​

Ejemplo con sesiones, sin ruido:

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 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 Aer con ese modelo. Si lo prefieres, puedes construir un modelo de ruido.

precaución

Una QPU puede verse afectada por distintos tipos de ruido. El modelo de ruido de Qiskit Aer utilizado aquí solo simula algunos de ellos y, por lo tanto, es probable que sea menos intenso que el ruido de una QPU real.

Para más detalles sobre qué errores se incluyen al inicializar un modelo de ruido desde una QPU, consulta la referencia de la API de Aer NoiseModel.

Ejemplo con ruido:

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()

Simulación de Clifford​

Dado que los circuitos de Clifford pueden simularse eficientemente con resultados verificables, la simulación de Clifford es una herramienta muy útil. Para un ejemplo detallado, consulta Simulación eficiente de Circuits estabilizadores con primitivas de Qiskit Aer.

Ejemplo:

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()

Probar la mitigación de errores localmente​

Con los Sampler y Estimator del lado del cliente (introducidos en qiskit-ibm-runtime v0.50.0), la supresión y la mitigación de errores se realizan en el cliente en lugar de en el servidor. Como resultado, estas opciones ahora surten efecto en el modo de prueba local, por lo que puedes experimentar con distintos métodos de mitigación de errores en un fake backend antes de consumir tiempo de QPU.

nota

Con las primitivas heredadas del lado del servidor, configurar una opción como resilience.measure_mitigation en un simulador local no tenía ningún efecto, porque el procesamiento de mitigación solo se ejecutaba en el servidor. Las primitivas del lado del cliente aplican ese procesamiento localmente.

Consideraciones sobre la sobrecarga de memoria y de tiempo de ejecución

El costo de la simulación ruidosa local crece exponencialmente con el número de qubits, y la mayoría de los portátiles no pueden simular más de unos 32 qubits. Dado que los métodos de supresión y mitigación de errores ahora se ejecutan localmente, añaden más sobrecarga de memoria y de tiempo de ejecución a la simulación base. Para que las pruebas locales sigan siendo viables, usa una de las siguientes opciones:

  • Un fake backend pequeño (como FakeManilaV2, que se usa a continuación).

  • Un simulador sin ruido.

  • Simulación de Clifford, que escala a un gran número de qubits.

El siguiente ejemplo activa la mitigación de errores de medición con Estimator y lo ejecuta en un fake backend. La opción measure_mitigation = True ahora se aplica localmente a tus circuits.

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

Recomendaciones
Fuente: Documentación de IBM Quantum — actualizado el 30 sept 2026
Versión en inglés en doQumentation — actualizado el 30 sept 2026
¿Problema con el sitio o la traducción?¿Problema de contenido? Editar en IBM Quantum docs