Migrer des simulateurs cloud vers les simulateurs locaux
En informatique quantique, le choix entre simulateurs et matériel quantique est crucial pour progresser dans le domaine. Si les simulateurs sont utiles pour tester et déboguer, à l'ère de l'utilité quantique, le développement quantique et l'avancement industriel nécessitent du matériel réel. Dans le cadre de la transition vers l'utilité quantique, les simulateurs cloud IBM Quantum® ont été retirés le 15 mai 2024. Ce guide explique ce retrait en détail et comment migrer des simulateurs cloud, comme ibmq_qasm_simulator, vers des simulateurs locaux.
Pourquoi les simulateurs cloud sont-ils retirés ?
Les simulateurs cloud sont retirés pour plusieurs raisons :
Les simulateurs ont des limites
Les simulateurs peuvent être utiles, mais ils sont trop limités pour être utilisés dans le cadre de la recherche ou de l'expérimentation :
-
Les simulateurs sont précieux pour comprendre les QPU (unités de traitement quantique) à petite échelle, mais leur utilité plafonne autour de 50 qubits, même avec accès à des supercalculateurs haute performance. Ce plafond est dû à la croissance exponentielle des ressources de calcul nécessaires pour simuler des ordinateurs quantiques plus grands (consulte Massively parallel quantum computer simulator, eleven years later pour l'explication complète). Explorer des ordinateurs quantiques de 100 qubits et plus nécessite du matériel.
-
Bien que certains simulateurs proposent des modèles de bruit, il est très difficile de capturer l'intégralité de la dynamique d'un QPU réel. Le matériel quantique offre aux chercheurs la possibilité d'affronter les défis inhérents aux ordinateurs quantiques — bruit, erreurs et décohérence — dans un environnement de test réaliste.
Utiliser le matériel quantique développe des compétences uniques
Interagir avec du matériel quantique développe des compétences et une expérience impossibles à acquérir en n'utilisant que des simulateurs :
-
L'interaction directe avec le matériel quantique développe des compétences, car tu dois implémenter ou utiliser des techniques de mitigation ou de suppression des erreurs pour obtenir des calculs fiables.
-
L'expérience pratique avec le matériel quantique développe une compréhension plus profonde des phénomènes quantiques et de la façon d'adapter les algorithmes aux caractéristiques des processeurs quantiques.
-
Travailler avec du matériel quantique apporte des perspectives pratiques sur les défis et les opportunités de l'informatique quantique, renforçant la capacité des développeurs à innover dans ce domaine.
Les algorithmes doivent être adaptés au matériel quantique
Les algorithmes quantiques performants doivent être adaptés pour exploiter les capacités du matériel quantique, en optimisant les performances et l'efficacité.
-
Le matériel quantique offre une représentation plus fidèle des QPU réels que les simulateurs.
-
Affiner les algorithmes pour le matériel quantique implique d'ajuster l'ansatz, les implémentations de circuits, les paramètres et la configuration pour maximiser les performances. Ce processus est mieux réalisé par l'expérimentation directe avec du matériel quantique.
Quand utiliser les simulateurs ?
Les simulateurs quantiques doivent être utilisés pour aider à développer et tester des programmes avant de les affiner et de les envoyer sur du matériel quantique. Les simulateurs locaux permettent de le faire avec de bonnes performances et une bonne efficacité. Les circuits de Clifford peuvent être simulés très efficacement et les résultats peuvent être vérifiés, ce qui est un moyen utile de gagner en confiance dans une expérience.
Le mode de test local ne dispose pas de suppression ou de mitigation des erreurs intégrée. Tu dois spécifier ces options explicitement. Consulte Configurer la mitigation des erreurs pour Qiskit Runtime pour plus de détails.
Migrer vers les simulateurs locaux
Avec qiskit-ibm-runtime 0.22.0 ou version ultérieure, tu peux utiliser le mode de test local pour remplacer les simulateurs cloud. Selon tes besoins, il existe plusieurs façons d'utiliser le mode de test local. Pour commencer, spécifie l'un des backends factices dans qiskit_ibm_runtime.fake_provider ou indique un backend Qiskit Aer lors de l'instanciation d'une primitive ou d'une session.
Guide pour choisir un simulateur
Utilise le tableau suivant pour t'aider à choisir un simulateur.
| Simulateur | Backends factices | AerSimulator | Simulation de Clifford |
|---|---|---|---|
| Objectif | Imite des QPU IBM® spécifiques à l'aide de snapshots | Simulation généraliste haute performance | Simulation efficace pour les circuits de Clifford |
| Modèle de bruit | Applique automatiquement le modèle de bruit des snapshots QPU | Personnalisé ou basé sur les données de calibration réelles d'un QPU | Idéal pour les simulations sans bruit |
| Taille du circuit | Limitée aux capacités du QPU imité | Peut gérer des circuits plus grands | Convient à des circuits très grands (des centaines de qubits) |
| Résultats | Temps d'exécution modéré pour les tests spécifiques au QPU | Temps d'exécution plus court pour un large éventail de simulations | Extrêmement rapide, adapté aux circuits stabilisateurs |
| Cas d'utilisation | Test du transpiler et du comportement spécifique au QPU | Développement général, modèles de bruit personnalisés | Grands circuits stabilisateurs, correction d'erreurs |
Pour la plupart des utilisateurs, AerSimulator est un bon choix en raison de sa flexibilité et de ses performances. Cependant, si ton travail cible un QPU spécifique, un backend factice pourrait être un meilleur choix.
Backends factices
Les backends factices imitent le comportement des QPU IBM en utilisant des snapshots. Ces snapshots contiennent des informations importantes sur le QPU, telles que la carte de couplage, les portes de base et les propriétés des qubits, qui sont utiles pour tester le transpiler et effectuer des simulations bruyantes du QPU. Le modèle de bruit du snapshot est automatiquement appliqué lors de la simulation.
Exemple :
from qiskit.circuit.library import RealAmplitudes
from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime.fake_provider import FakeManilaV2
from qiskit_ibm_runtime import SamplerV2 as Sampler, QiskitRuntimeService
service = QiskitRuntimeService()
# 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
Tu peux utiliser le mode de test local avec des simulateurs de Qiskit Aer, qui offre une simulation haute performance capable de gérer des circuits plus grands et des modèles de bruit personnalisés. Il prend également en charge le mode de simulation de Clifford, qui permet de simuler efficacement des circuits de Clifford avec un grand nombre de qubits.
Exemple avec sessions, sans bruit :
Le bloc de code suivant retournera une erreur pour les utilisateurs du plan Open, car il utilise des sessions. Les charges de travail sur le plan Open ne peuvent s'exécuter qu'en mode job ou en mode batch.
from qiskit_aer import AerSimulator
from qiskit.circuit.library import RealAmplitudes
from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime import Session, SamplerV2 as Sampler, QiskitRuntimeService
service = QiskitRuntimeService()
# 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()
result = sampler.run([isa_qc]).result()
Pour simuler avec du bruit, spécifie un QPU (matériel quantique) et soumets-le à Aer. Aer construit un modèle de bruit basé sur les données de calibration de ce QPU et instancie un backend Aer avec ce modèle. Si tu préfères, tu peux construire un modèle de bruit.
Exemple avec bruit :
from qiskit_aer import AerSimulator
from qiskit.circuit.library import RealAmplitudes
from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler
service = QiskitRuntimeService()
# Bell Circuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()
# Specify a QPU to use for the noise model
real_backend = service.backend("ibm_brisbane")
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 de 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, consulte Simulation efficace des circuits stabilisateurs avec les primitives Qiskit Aer.
Exemple :
import numpy as np
from qiskit.circuit.library import EfficientSU2
from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler
service = QiskitRuntimeService()
n_qubits = 500 # <---- note this uses 500 qubits!
circuit = EfficientSU2(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_circuit = pm.run(circuit)
sampler = Sampler(mode=aer_sim)
result = sampler.run([(isa_circuit, params)]).result()