Vue d’ensemble des simulateurs quantiques dans le QDK

Le MicrosoftQuantum Development Kit (QDK) inclut des simulateurs quantiques qui exécutent des programmes quantiques sur votre ordinateur local. Utilisez ces simulateurs locaux pour tester et développer vos programmes avant de les soumettre aux cibles Azure Quantum.

Le QDK fournit quatre simulateurs principaux pour exécuter des programmes quantiques :

  • Le simulateur épars
  • Le simulateur de stabilisateurs
  • Simulateur GPU
  • Simulateur CPU

Le simulateur épars

Le simulateur parcimonieux représente des états de qubit en tant que vecteurs épars et utilise l’algèbre des matrices éparses pour simuler rapidement des programmes qui génèrent peu d’amplitudes non nulles. Il s'agit du simulateur par défaut pour les programmes Q# et OpenQASM dans l’extension QDK et pour les API qsharp.run et openqasm.runPython. 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 le package QDKPython. Ce simulateur est le seul simulateur disponible dans l’extension QDK, l’extension l’utilise donc automatiquement lorsque vous exécutez des programmes OpenQASM et Q# dans VS Code. Dans VS Code, utilisez la Q#DumpMachine fonction 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 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 à états creux des programmes Qiskit, mais il ne prend pas en charge les modèles de bruit pour les simulations Qiskit.

Pour plus d’informations sur l’exécution de simulations dans l’extension QDK , consultez Exécuter des simulations quantiques dans l’extension QDK pour Visual Studio Code.

Simulateur de stabilisateur

Le simulateur de stabilisateur simule rapidement et efficacement des programmes dominés par Clifford avec des milliers de qubits. Les portes Clifford sont des composants courants des circuits de correction d’erreurs quantiques. Clifford les opérations n’augmentent pas le nombre de branches stabilisatrices, de sorte que le simulateur peut les appliquer efficacement même dans des circuits larges. Les opérations courantes Clifford sont les suivantes :

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

Le simulateur de stabilisateur utilise également la ramification des stabilisateurs pour simuler des circuits avec un nombre limité d’opérations non-Clifford. Le simulateur prend en charge les opérations non-Clifford suivantes :

  • $T$ et $T^\dagger$
  • Rotations à angle arbitraire $R_X$, $R_Y$, $R_Z$, $R_{XX}$, $R_{YY}$ et $R_{ZZ}$

Chaque opération non-Clifford peut augmenter le nombre de branches stabilisatrices. L’ajout d’opérations non-Clifford peut augmenter l’utilisation de la mémoire et le temps de capture de manière exponentielle. Utilisez le simulateur de stabilisateurs pour les circuits de grande taille comportant principalement des opérations de type Clifford et un nombre modéré d’opérations non-Clifford operations. Utilisez un simulateur à états creux ou à état complet pour les circuits comportant un grand nombre d’opérations non-Clifford.

Le simulateur de stabilisateurs prend en charge l’exécution adaptative, le bruit Pauli et la perte de qubits. Il 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.

Dans les API Python qui proposent un sélecteur de simulateur, utilisez soit "stabilizer" ou "clifford" pour sélectionner le simulateur de stabilisateurs.

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. Le simulateur prend en charge tous les types de portes logiques, mais nécessite des ressources informatiques importantes. 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 GPU simulateur accepte QIR ou Qiskit en tant qu’entrée via certaines QDKPython API de package. L’extension VS Code ne prend pas en charge le simulateur GPU. 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 exécute des programmes avec n’importe quel type de porte quantique. Mais il est plus lent, car il ne peut pas exécuter plusieurs exécutions 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 si votre programme a peu de qubits et ne nécessite pas de nombreux shots.

Le simulateur CPU accepte une entrée QIR ou Qiskit. Vous pouvez l’utiliser via certaines QDKPython API de package, mais pas via 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 ?

Tenez compte de ces facteurs lorsque vous choisissez un simulateur :

  • Votre environnement de développement (VS Code ou Python)
  • Le framework de programmation quantique que vous utilisez
  • 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 la disponibilité de chaque QDK simulateur et les infrastructures de programmation quantique prises en charge :

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

Simulations dans l’extension QDK pour VS Code

L’extension QDK pour VS Code prend uniquement en charge le simulateur sparse. Pour utiliser le simulateur sparse, exécutez votre fichier Q# ou OpenQASM dans VS Code. Vous pouvez ajouter des modèles de bruit de Pauli noise models to sparse simulations of Q# aux simulations à états creux des programmes VS Code, mais pas aux programmes OpenQASM.

Simulations dans le QDKPython package

Le QDKPython package prend en charge plusieurs frameworks de programmation quantique et les quatre QDK simulateurs. La compatibilité varie selon le framework et l’API.

Le tableau suivant répertorie les simulateurs et les frameworks de programmation pris en charge par chaque Python API :

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

Contenu connexe

  • Dernière mise à jour :