Qiskit Runtime 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.0
  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, especifique uno de los backends falsos de qiskit_ibm_runtime.fake_provider o especifique un backend Qiskit Aer al instanciar una primitiva Qiskit Runtime 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
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 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, 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 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 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()

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
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óximos pasos