Modo de prueba local

• Versiones del paquete

  El código de esta página se ha desarrollado teniendo en cuenta los siguientes requisitos. Recomendamos utilizar estas versiones o versiones más recientes.

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

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

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

• Falsos backends : Los backends falsos en qiskit_ibm_runtime.fake_provider imitan los comportamientos de IBM® QPUs mediante el uso de instantáneas QPU. Las instantáneas de la QPU contienen información importante sobre la QPU, como el mapa de acoplamiento, las puertas base y las propiedades de los qubits, que son útiles para probar el transpilador y realizar simulaciones ruidosas 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 proporcionan una simulación de mayor rendimiento que puede manejar circuitos más grandes y modelos de ruido personalizados. Si utiliza AerSimulator en modo de prueba local, dispondrá de una lista de opciones de métodos de simulación. Vea el ejemplo del modo de simulación Cl ifford, que demuestra cómo simular eficientemente circuitos Clifford con un gran número de qubits.

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

    Consulte la AerSimulator para más información.

    • "automatic": Método de simulación por defecto. Selecciona automáticamente el método de simulación en función del circuito y del modelo de ruido.

    • "statevector": Una simulación densa de vectores de estado que puede muestrear resultados de mediciones de circuitos ideales con todas las mediciones al final del circuito. Para las simulaciones ruidosas, cada disparo muestrea un circuito ruidoso muestreado aleatoriamente a partir del modelo de ruido.

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

    • "stabilizer": Un simulador eficiente del estado del estabilizador Clifford que puede simular circuitos Clifford ruidosos si todos los errores en el modelo de ruido son también errores Clifford.

    • "extended_stabilizer": Un simulador aproximado para circuitos Clifford + T basado en la descomposición del estado en un estado clasificado-estabilizador. El número de términos crece con el número de puertas no Clifford (T).

    • "matrix_product_state": Un simulador tensor-red estado-vector que utiliza una representación Matrix Product State (MPS) para el estado. Esto puede hacerse con o sin truncamiento de las dimensiones de enlace MPS, dependiendo de las opciones del simulador. El comportamiento por defecto es sin truncamiento.

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

    • "superop": Una simulación matricial de superoperador denso de un circuito ideal o ruidoso. Esto simula la matriz de superoperadores del propio circuito, en lugar de la evolución de un estado cuántico inicial. Este método puede simular puertas y reinicios ideales y ruidosos, pero no admite mediciones.

    • "tensor_network": Una simulación basada en redes tensoriales que admite tanto vectores de estado como matrices de densidad. Actualmente sólo está disponible para GPU y se acelera utilizando las API de cuQuantum cuTensorNet .

Ejemplo de backends falsos

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

AerSimulator ejemplos

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, especifique una QPU (hardware cuántico) y envíela a Aer. Aer construye un modelo de ruido basado en los datos de calibración de esa QPU e instantiza un backend Aer con ese modelo. Si lo prefieres, puedes construir un modelo de ruido.

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 Clifford pueden simularse eficazmente con resultados verificables, la simulación Clifford es una herramienta muy útil. Para ver un ejemplo detallado, consulte Simulación eficiente de circuitos estabilizadores con primitivas 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 a nivel local

Con el lado del cliente y Sampler Estimator (introducido en v0.50.0qiskit-ibm-runtime ), la supresión y la mitigación de errores se producen en el cliente, en lugar de en el servidor. Como resultado, estas opciones ahora se aplican en el modo de prueba local, lo que te permite probar diferentes métodos de mitigación de errores en un backend simulado antes de dedicar tiempo de la QPU.

El siguiente ejemplo activa la mitigación de errores de medición con Estimator y la ejecuta en un backend simulado. La opción measure_mitigation = True ya se ha aplicado a tus circuitos a nivel local.

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

Pruebas locales frente a trabajos de simulación

El modo de prueba local se ejecuta en tu propio ordenador. Es una buena forma de desarrollar y depurar un programa, así como de ver cómo podría ser el resultado, pero no te permite saber cuánto cobraría realmente la QPU ni si el servicio aceptará el trabajo.

A diferencia de las pruebas locales, un trabajo de simulación ejecuta tu carga de trabajo a través del servicio « IBM Quantum Compute » en un dispositivo simulado sin utilizar tiempo de la QPU, lo que te permite ver el número de unidades de recurso (RU) que el trabajo consumiría en la QPU real. Además, proporciona validación por parte del proveedor y el calendario de sincronización del circuito previa solicitud.

Un flujo de trabajo habitual consiste en realizar iteraciones sobre los circuitos y los resultados con un backend simulado y, a continuación, ejecutar una tarea de prueba como última comprobación antes de ejecutarla en la QPU real. Para ver una comparación completa, consulta la sección «Comparación entre dispositivos simulados y backends falsos ».

Próximos pasos