Vue d’ensemble des simulateurs quantiques dans le QDK

Le MicrosoftQuantum Development Kit (QDK) inclut un ensemble de simulateurs quantiques qui vous permettent d’exécuter des programmes quantiques sur votre ordinateur local. Utilisez les simulateurs locaux pour itérer sur vos programmes avant de les soumettre à des cibles Azure Quantum.

Le QDK possède quatre simulateurs.

  • Le simulateur épars
  • Simulateur Clifford
  • Simulateur GPU
  • Simulateur CPU

Le simulateur épars

Le simulateur éparse est le simulateur par défaut dans le QDK. Ce simulateur représente des états qubits en tant que vecteurs éparses pour tirer parti de l’algèbre de matrice éparse pour les simulations rapides, en particulier pour les programmes qui ne génèrent pas de nombreux états de superposition. Utilisez le simulateur éparse lorsque vous souhaitez effectuer des simulations rapides de programmes Q#, OpenQASM ou Qiskit, ou pour afficher l’état quantique de votre programme pendant la simulation.

Le simulateur sparse est disponible à la fois dans l’extension QDK pour Visual Studio Code (VS Code) et dans le package QDKPython. Ce simulateur est le seul simulateur disponible dans l’extension QDK, donc le compilateur appelle automatiquement le simulateur parcimonieux lorsque vous exécutez les programmes Q# et OpenQASM dans VS Code. Avec le simulateur épars dans VS Code, vous pouvez utiliser la fonction Q#DumpMachine ou le débogueur pour afficher des vecteurs d'état qubit à différents points de la simulation.

L’extension VS Code et le package Python prennent toutes deux en charge les modèles de bruit pour les simulations éparses de programmes OpenQASM et Q#. Seul le package Python prend en charge la simulation éparse pour les programmes Qiskit, mais sans prise en charge du modèle de bruit.

Pour plus d’informations sur le simulateur creux, consultez le simulateur creux.

Simulateur Clifford

Le simulateur Clifford est rapide et efficace pour les programmes comportant jusqu’à plusieurs milliers de qubits, mais ne peut simuler que des programmes contenant uniquement des portes Clifford. Clifford les portes sont des composants courants des circuits de correction d’erreurs. L’ensemble de Clifford portes se compose des portes H, S et CX, et toutes les portes qui peuvent être construites à partir de ces trois portes. Les portes suivantes Clifford sont des composants courants des circuits quantiques :

  • $X$, $Y$ et $Z$
  • $S$ et $S^\dagger$
  • $H$, ou Hadamard
  • $CX$, $CY$ et $CZ$
  • SWAP et iSWAP

Le simulateur Clifford est disponible dans le package QDKPython pour les programmes Q#, OpenQASM, Qiskit et QIR, mais n'est pas disponible dans l’extension QDK pour VS Code.

Simulateur GPU

Le simulateur GPU est un simulateur à état complet qui utilise les commandes GPU de votre machine pour exécuter de nombreuses exécutions de votre programme quantique en parallèle. Ce simulateur peut exécuter des programmes qui contiennent n’importe quel type de porte, mais est coûteux à exécuter. Le simulateur peut modéliser jusqu’à 27 qubits. La puissance de votre machine GPU détermine les performances, mais celles-ci sont optimales pour les programmes comportant environ 20 qubits et un grand nombre d’exécutions.

Le simulateur GPU prend Qiskit ou QIR en entrée, et est disponible via les API de certains packages QDKPython, mais pas dans l’extension VS Code. Il existe également un support étendu pour les modèles de bruit sur n’importe quel type de porte quantique ou d’opération.

Simulateur CPU

Comme le GPU simulateur, le CPU simulateur est un simulateur à état complet qui peut exécuter des programmes qui contiennent n’importe quel type de porte quantique. Toutefois, le CPU simulateur est plus lent, car il ne peut pas exécuter plusieurs tirs en parallèle. Ce simulateur effectue un scale-up jusqu’à environ 25 qubits, mais ralentit de façon exponentielle avec plus de qubits en raison de problèmes de mémoire. Utilisez le CPU simulateur lorsque votre machine n’a pas de GPU, ou lorsque votre programme a peu de qubits et que vous n’exécutez pas un grand nombre d'exécutions.

Le simulateur CPU prend Qiskit ou QIR en entrée, et est disponible via les API de certains packages QDKPython, mais pas dans l’extension VS Code. Il existe également un support étendu pour les modèles de bruit sur n’importe quel type de porte quantique ou d’opération.

Quel simulateur dois-je utiliser ?

Le meilleur simulateur à utiliser dépend de plusieurs facteurs, tels que :

  • Votre environnement de développement (VS Code ou Python)
  • Infrastructure de programmation quantique dans laquelle vous développez
  • La complexité de votre programme et le nombre de tirs
  • Fonctionnalités matérielles de votre ordinateur local
  • Les cibles Azure Quantum ou tout autre matériel quantique sur lequel vous souhaitez exécuter vos programmes
  • Modèles de bruit que vous souhaitez créer

Le tableau suivant récapitule les QDK options et les frameworks de programmation quantique que vous pouvez utiliser pour chaque simulateur :

Simulateur Availability Frameworks pris en charge
Partiellement alloué Extension VS Code et package Python Q#, OpenQASM, Qiskit
Clifford Python paquet Q#, OpenQASM, Qiskit, QIR
GPU Python paquet Qiskit, QIR
CPU Python paquet Qiskit, QIR

Simulations dans l’extension QDK pour VS Code

Le simulateur sparse est le seul simulateur disponible dans l’extension QDK pour VS Code. Pour utiliser le simulateur parcimonieux, exécutez votre fichier Q# ou OpenQASM dans VS Code. Vous pouvez ajouter des modèles de bruit limités au simulateur clairsemé pour les programmes Q# dans VS Code, mais pas pour les programmes OpenQASM.

Simulations dans le QDKPython package

L’environnement de développement QDKPython prend en charge plusieurs frameworks quantiques et les quatre simulateurs QDK, mais tous les simulateurs ne sont pas compatibles avec tous les frameworks et API.

Ce tableau présente les simulateurs que vous pouvez utiliser pour chaque Python API qui appelle un QDK simulateur et l’infrastructure de programmation prise en charge par chaque API :

Python Interface de Programmation d'Applications (API) Partiellement alloué Clifford GPU CPU Framework de programmation
qsharp.run ✅ ✅ Q#
openqasm.run ✅ ✅ OpenQASM
qiskit.QSharpBackend ✅ Qiskit
simulation.NeutralAtomDevice ✅ ✅ ✅ QIR
simulation.NeutralAtomBackend ✅ ✅ ✅ Qiskit
simulation.run_qir ✅ ✅ ✅ QIR

Contenu connexe

  • Last updated on