Comment installer et utiliser l’estimateur de ressources Microsoft Quantum

L’estimateur de ressources Microsoft Quantum fait partie de l’Microsoft Quantum Development Kit (QDK). Dans cet article, vous allez apprendre à installer l’estimateur de ressources quantiques et à exécuter une estimation pour un programme Q# simple avec un modèle d’architecture par défaut.

Prerequisites

Pour suivre les étapes décrites dans cet article, vous devez installer les éléments suivants :

• La dernière version de Visual Studio Code (VS Code)
• Dernière version de l’extension QDK installée dans VS Code
• Les versions les plus récentes de l’Python extension et de l’extension Jupyter dans VS Code

Installer l’estimateur de ressources quantiques

L’estimateur de ressources est disponible via le qdk.qrePython module. Pour utiliser l’estimateur de ressource, installez la dernière version du qdkPython package avec les qre éléments supplémentaires :

pip install --upgrade "qdk[qre]"

Exécuter une estimation simple des ressources avec les paramètres par défaut

Pour effectuer une estimation de ressource de base, passez un modèle d’application, un modèle d’architecture matérielle et un modèle de correction d’erreur à l’estimateur de ressource. Ensuite, exécutez l’estimateur de ressource pour obtenir les résultats. L’exemple suivant exécute l’estimateur de ressources à partir de Jupyter Notebook dans VS Code.

Créer un modèle d’application

Pour cet exemple, utilisez l’algorithme du modèle d’Ising 1D issu des exemples Q# dans l’extension QDK pour VS Code. Vous pouvez également utiliser l’un de vos programmes Q# existants.

Écrire un programme Q#

1. Dans VS Code, créez un fichier texte et enregistrez le fichier sous ising-1d-sample.qs.
2. Sur la première ligne du fichier, entrez l’exemple pour afficher la liste d’exemples de programmes Q#.
3. Choisissez l’exemple Ising Model (Simple 1D), puis enregistrez le fichier.

Créer une application

Utilisez le programme Q# pour créer un modèle d’application pour l’estimateur de ressources.

1. Pour créer un fichier Jupyter Notebook dans VS Code, ouvrez la palette de commandes et entrez Create : New Jupyter Notebook.

2. Dans la première cellule du bloc-notes, évaluez le programme Q#.

   from pathlib import Path
   from qdk import qsharp
   
   qsharp.eval(Path("ising-1d-sample.qs").read_text(encoding="utf-8"))
   

   Ce code crée un Main objet dans l’espace qdk.code de noms qui contient le programme Q#.

3. Dans une nouvelle cellule, créez une application estimateur de ressources à partir du programme Q#.

   import qdk
   from qdk.qre.application import QSharpApplication
   
   app = QSharpApplication(qdk.code.Main)
   

Créer un modèle d’architecture

Pour l’architecture matérielle, utilisez le modèle par défaut GateBased avec lequel l’estimateur de ressource est fourni. Le modèle GateBased nécessite des entrées pour le taux d’erreur, le temps de porte et le temps de mesure.

Dans une nouvelle cellule, créez une architecture basée sur une porte avec un taux d’erreur de 10^{-4}$, une heure de porte de 100 ns et une durée de mesure de 500 ns.

from qdk.qre.models import GateBased

# Times are in units of nanoseconds
arch = GateBased(error_rate=1e-4, gate_time=100, measurement_time=500)

Exécuter une estimation

Pour exécuter une estimation, utilisez la estimate fonction et transmettez les entrées suivantes :

• Application
• Architecture
• Requête ISA (Physical Instruction Set)
• Taux d’erreur maximal

La requête ISA indique à l’estimateur de ressource quelles combinaisons de code de correction d’erreur et de protocoles de distillation T factory à évaluer. L’estimateur de ressources détermine l’ensemble de résultats optimisé sur la frontière de Pareto à partir de ces combinaisons. Pour cet exemple, utilisez le SurfaceCode QEC et le protocole de distillation RoundBasedFactory par défaut fournis avec l’estimateur de ressources.

from qdk.qre import estimate
from qdk.qre.models import SurfaceCode, RoundBasedFactory

results = estimate(app, arch, isa_query=SurfaceCode.q() * RoundBasedFactory.q(), max_error=0.01)```

Afficher les résultats

Pour afficher les combinaisons optimales du nombre de qubits physiques et du temps d’exécution du programme, utilisez la as_frame méthode pour afficher les résultats d’estimation dans un DataFrame pandas.

results.as_frame()

Pour tracer les résultats, utilisez la plot_estimates méthode et passez une unité pour le temps d’exécution.

from qdk.qre import plot_estimates

plot_estimates(results, figsize=(6, 4), runtime_unit="ms")