Mode de test local

• Versions de package

  Le code de cette page a été développé en tenant compte des exigences suivantes. Nous recommandons d'utiliser ces versions ou des versions plus récentes.

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

Utilisez le mode de test local (disponible à partir de qiskit-ibm-runtime v0.22.0 ) pour tester les programmes avant de les affiner et de les envoyer au matériel quantique réel. Après avoir utilisé le mode de test local pour vérifier votre programme, il vous suffit de modifier le nom du backend pour l'exécuter sur une QPU.

Pour utiliser le mode de test local, spécifiez l'un des backends fictifs disponibles dans qiskit_ibm_runtime.fake_provider ou indiquez un backend Qiskit Aer lors de l'instanciation d'une primitive « IBM Quantum® » ou d'une session.

• Faux backends : Les faux backends de qiskit_ibm_runtime.fake_provider imitent les comportements des QPU de IBM® en utilisant des snapshots de QPU. Les instantanés de la QPU contiennent des informations importantes sur la QPU, telles que la carte de couplage, les portes de base et les propriétés des qubits, qui sont utiles pour tester le transpileur et effectuer des simulations bruitées de la QPU. Le modèle de bruit de l'instantané est automatiquement appliqué pendant la simulation.

• Simulateur Aer : Les simulateurs de Qiskit Aer offrent une simulation plus performante, capable de gérer des circuits plus importants et des modèles de bruit personnalisés. Une liste d'options de méthodes de simulation est disponible lorsque vous utilisez AerSimulator en mode de test local. Voir l' exemple du mode de simulation Clifford, qui montre comment simuler efficacement des circuits Clifford avec un grand nombre de qubits.

  • Liste des méthodes de simulation disponibles sur Qiskit Aer

    Pour plus d'informations, voir la AerSimulator pour plus d'informations.

    • "automatic": Méthode de simulation par défaut. Sélection automatique de la méthode de simulation en fonction du circuit et du modèle de bruit.

    • "statevector": Une simulation de vecteur d'état dense qui peut échantillonner les résultats de mesures de circuits idéaux avec toutes les mesures à la fin du circuit. Pour les simulations bruyantes, chaque tir échantillonne un circuit bruyant échantillonné de manière aléatoire à partir du modèle de bruit.

    • "density_matrix": Une simulation de matrice de densité qui peut échantillonner les résultats de mesure de circuits bruyants avec toutes les mesures à la fin du circuit.

    • "stabilizer": Un simulateur d'état stabilisateur de Clifford efficace qui peut simuler des circuits de Clifford bruyants si toutes les erreurs dans le modèle de bruit sont également des erreurs de Clifford.

    • "extended_stabilizer": Un simulateur approximatif pour les circuits Clifford + T basé sur la décomposition de l'état en un état stabilisateur classé. Le nombre de termes augmente avec le nombre de portes non-Clifford (T).

    • "matrix_product_state": Un simulateur de vecteur d'état de réseau tensoriel qui utilise une représentation d'état de produit matriciel (MPS) pour l'état. Cette opération peut être effectuée avec ou sans troncature des dimensions de la liaison MPS, en fonction des options du simulateur. Par défaut, il n'y a pas de troncature.

    • "unitary": Une simulation de matrice unitaire dense d'un circuit idéal. Cela permet de simuler la matrice unitaire du circuit lui-même, plutôt que l'évolution d'un état quantique initial. Cette méthode permet uniquement de simuler des portes; elle ne prend pas en charge les mesures, la réinitialisation ou le bruit.

    • "superop": Une simulation matricielle dense de superopérateurs d'un circuit idéal ou bruyant. Cela permet de simuler la matrice des superopérateurs du circuit lui-même, plutôt que l'évolution d'un état quantique initial. Cette méthode permet de simuler des portes et des réinitialisations idéales et bruyantes, mais elle ne permet pas d'effectuer des mesures.

    • "tensor_network": Une simulation basée sur un réseau tensoriel qui prend en charge à la fois le vecteur d'état et la matrice de densité. Actuellement, cette fonction n'est disponible que pour le GPU et est accélérée par l'utilisation de cuQuantum cuTensorNet APIs.

Exemple de faux backends

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 exemples

Exemple avec sessions, sans bruit :

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

Pour simuler avec du bruit, spécifiez une QPU (matériel quantique) et soumettez-la à Aer. Aer construit un modèle de bruit basé sur les données d'étalonnage de cette QPU et instancie un backend Aer avec ce modèle. Si vous préférez, vous pouvez construire un modèle de bruit.

Exemple avec bruit :

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

Simulation Clifford

Parce que les circuits de Clifford peuvent être simulés efficacement avec des résultats vérifiables, la simulation de Clifford est un outil très utile. Pour un exemple approfondi, voir Simulation efficace de circuits stabilisateurs avec les primitives Qiskit Aer.

Exemple :

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

Tester la réduction des erreurs en local

Avec les fonctionnalités côté client et Sampler Estimator (présentées dans v0.50.0qiskit-ibm-runtime ), la suppression et l'atténuation des erreurs s'effectuent côté client plutôt que côté serveur. Par conséquent, ces options s'appliquent désormais en mode de test local, ce qui vous permet d'expérimenter différentes méthodes d'atténuation des erreurs sur un backend fictif avant d'engager du temps de calcul sur le QPU.

L'exemple suivant active la réduction des erreurs de mesure avec Estimator et l'exécute sur un backend fictif. Cette option measure_mitigation = True est désormais appliquée à vos circuits au niveau 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()

Etapes suivantes