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.1
  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 de qiskit_ibm_runtime.fake_provider ou 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
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 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, 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()

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

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

Etapes suivantes