Comment soumettre des programmes Q# avec Visual Studio Code

Envoi des Q# tâches à Azure Quantum

Découvrez comment utiliser VS Code pour exécuter, déboguer et envoyer un Q# programme à Azure Quantum.

Prérequis

Pour plus d’informations sur l’installation, consultez Configurer l’extensionQDK.

• Un Azure Quantum espace de travail dans votre Azure abonnement. Pour créer un espace de travail, consultez Créer un Azure Quantum espace de travail.
• La version la plus récente de Visual Studio Code ou ouvrez VS Code sur le Web.
• Dernière version de l’extensionAzure Quantum Development Kit.

Charger un Q# exemple de programme

1. Dans VS Code, sélectionnez Fichier > nouveau fichier texte et enregistrez le fichier en tant que RandomNum.qs.

2. Ouvrez RandomNum.qs et tapez sample, puis sélectionnez l’exemple Bit aléatoire dans la liste des options et enregistrez le fichier.

   

Exécuter un programme Q#

1. Pour tester l’exécution de votre programme localement sur le simulateur intégré, cliquez sur Exécuter dans la liste des commandes en regard de l’opération de point d’entrée, ou appuyez sur Ctrl + F5. Votre résultat s’affichera sur la console de débogage.

2. Pour déboguer votre programme avant de le soumettre Azure Quantum, cliquez sur Déboguer dans la liste des commandes en regard de l’opération de point d’entrée, ou appuyez sur F5. Veuillez utiliser les commandes de débogage en haut pour passer à l'étape suivante, entrer dans le code ou en sortir. Pour plus d’informations sur le débogage Q# des programmes, consultez Test et débogage.

   Capturez une capture d'écran du Q# fichier dans Visual Studio Code montrant où trouver le code lens avec les commandes d'exécution et de débogage.

Visualiser l’histogramme de fréquence

L’histogramme de fréquence représente la distribution des résultats obtenus à partir de l’exécution d’un programme quantique plusieurs fois, ou des « captures ». Chaque barre de l’histogramme correspond à un résultat possible, et sa hauteur représente le nombre de fois où le résultat est observé. L’histogramme de fréquence permet de visualiser la distribution de probabilité de ces résultats.

1. Sélectionnez l’affichage -> Palette de commandes et tapez 'histogramme', ce qui affiche la commande QDK: Exécutez le fichier et affichez l’histogramme. Vous pouvez également choisir histogramme dans la liste des commandes qui précèdent l’opération de point d’entrée. Sélectionnez cette option pour ouvrir la fenêtre d’histogramme Q# .

   

2. Entrez un certain nombre de captures pour exécuter le programme, par exemple 100 captures, puis appuyez sur Entrée. L’histogramme s’affiche dans la fenêtre d’histogramme Q# .

3. Cliquez sur l’icône des paramètres en haut à gauche pour afficher les options.

   

4. Cliquez sur une barre pour afficher le pourcentage de ce résultat. Dans ce cas, il existe deux résultats possibles, 0 et 1, et le pourcentage de chaque résultat est proche de 50 %.

   

Visualiser le circuit quantique

Les diagrammes de circuits quantiques sont une représentation visuelle des opérations quantiques. Ils montrent le flux de qubits par le biais du programme quantique, y compris les portes et les mesures qui leur sont appliquées. Pour plus d’informations, consultez diagrammes de circuits quantiques dans Visual Studio Code.

1. Sélectionnez Affichage -> Palette de commandes et tapez circuit, ce qui fait apparaître la commande QDK : Afficher le circuit. Vous pouvez également sélectionner Circuit dans la liste des commandes en regard de l’opération de point d’entrée.

   

2. Le circuit s’affiche dans la fenêtre du Q# circuit. Le diagramme de circuit montre un registre qubit initialisé à l’état |0⟩. Ensuite, une porte Hadamard, H, est appliquée au qubit, suivie d’une opération de mesure, représentée par un symbole de compteur. Pour plus d’informations, consultez les conventions de circuits Quantum.

   

Connectez-vous à Azure Quantum et soumettez votre tâche.

Vous pouvez vous connecter et envoyer des travaux directement à partir de VS Code. Pour cet exemple, vous soumettez un travail au simulateur Rigetti.

1. Sélectionnez Affichage -> Palette de commandes et saisissez QDK: Se connecter à un Azure Quantum espace de travail. Appuyez sur Entrée.

2. Sélectionnez Azure le compte, puis suivez les invites pour vous connecter à votre annuaire, abonnement et espace de travail préférés.

   Remarque

   Si vous disposez d’une chaîne de connexion, vous pouvez sélectionner chaîne de connexion et coller la chaîne de connexion correspondant à votre Azure Quantum espace de travail. Pour plus d’informations, consultez Se connecter à un espace de travail Quantum à l’aide d’un chaîne de connexion.

3. Une fois connecté, dans le volet Explorateur, développez Espaces de travail Quantum.

4. Développez votre espace de travail et étendez le fournisseur Rigetti.

   Remarque

   En cas de problème de connexion à Azure Quantum, une icône d’avertissement s’affiche à côté du nom de l’espace de travail. Pointez sur le nom de l’espace de travail pour afficher les informations d’erreur.

5. Sélectionnez rigetti.sim.qvm comme votre target.

   

6. Sélectionnez l’icône de lecture à droite du target nom pour commencer à soumettre le programme actuel Q# .

   

7. Ajoutez un nom pour identifier le travail.

8. Ajoutez le nombre de captures ou le nombre de fois que le programme est exécuté.

9. Appuyez sur Entrée pour envoyer le travail. L’état du travail s’affiche en bas de l’écran.

10. Développez Jobs et passez la souris sur votre job, ce qui permet d'afficher les heures et le statut de votre job.

11. Pour afficher les résultats, sélectionnez l’icône cloud en regard du nom du travail pour télécharger les résultats à partir de votre stockage d’espace de travail et l’afficher dans VS Code.

    

Envoyer des travaux à Azure Quantum partir de Jupyter Notebook

Découvrez comment utiliser VS Code pour exécuter, déboguer et soumettre un Q#Jupyter Notebook à Azure Quantum.

Prérequis

Pour plus d’informations sur l’installation, consultez Configurer l’extensionQDK.

• Un Azure Quantum espace de travail dans votre Azure abonnement. Pour créer un espace de travail, consultez Créer un Azure Quantum espace de travail.

• Un Python environnement avec Python et Pip installé.

• VS Code avec les extensions Azure Quantum Development Kit, Python et Jupyter installées.

• La bibliothèque qdkPython avec les extras azurejupyter et le paquet ipykernel.

  python -m pip install --upgrade "qdk[azure,jupyter]" ipykernel
  

Exécuter et tester votre programme dans le simulateur local

1. Dans VS Code, sélectionnez Afficher > la palette de commandes et sélectionnez Créer : Nouveau Jupyter Notebook.

2. En haut à droite, VS Code détectera et affichera la version de Python ainsi que l'environnement virtuel Python sélectionné pour le notebook. Si vous avez plusieurs Python environnements, vous devrez peut-être sélectionner un noyau à l’aide du sélecteur de noyau en haut à droite. Si aucun environnement n’a été détecté, consultez Jupyter Notebookinformations d’installation dans VS Code.

3. Dans la première cellule du notebook, exécutez le code suivant Python pour importer les modules nécessaires :

   from qdk import qsharp
   import qdk.azure
   

   • Le qdk.qsharp module active la commande magique qui vous permet d’entrer du %%qsharp code directement dans une cellule.
   • Le qdk.azure module fournit une connectivité à votre Azure Quantum espace de travail.

   Remarque

   Si le JupyterPython noyau ipykernel n’est pas détecté, alors VS Code vous invitera à l’installer.

4. Ajoutez une autre cellule et entrez ce Q# code qui retourne un nombre spécifié par l’utilisateur de bits aléatoires :

   Remarque

   Notez que dès que vous tapez dans la commande magique %%qsharp, la cellule du bloc-notes change de type Python à Q#.

   %%qsharp
   
   operation Random() : Result {
       use q = Qubit();
       H(q);
       let result = M(q);
       Reset(q);
       return result
   }
   
   operation RandomNBits(N: Int): Result[] {
       mutable results = [];
       for i in 0 .. N - 1 {
           let r = Random();
           results += [r];
       }
       return results
   }
   

5. Pour tester votre opération, vous pouvez utiliser la eval méthode, qui peut appeler n’importe quelle Q# opération précédemment définie dans le notebook :

   qsharp.eval("RandomNBits(4)")
   

   [Zero, One, One, Zero]
   

6. Pour exécuter votre programme sur le simulateur local, utilisez la run méthode. Spécifiez le shotsou le nombre de fois où exécuter le programme et le simulateur retourne les résultats sous forme de Python liste.

   qsharp.run("RandomNBits(4)", shots=10)
   

   [[One, One, One, One],
   [Zero, Zero, One, Zero],
   [One, Zero, Zero, One],
   [Zero, One, Zero, Zero],
   [One, Zero, One, One],
   [One, Zero, One, Zero],
   [One, One, One, Zero],
   [One, One, One, One],
   [Zero, Zero, Zero, One],
   [One, Zero, Zero, One]]
   

Visualiser le circuit quantique

Vous pouvez visualiser des circuits quantiques à l’aide du qdk.widgets module. Ce module fournit un widget qui affiche un diagramme de circuit quantique en tant qu’image SVG. Pour plus d’informations, consultez diagrammes de circuits quantiques avec Jupyter Notebook.

Ajoutez le code suivant à une nouvelle cellule pour visualiser le circuit :

from qdk.qsharp import circuit
from qdk.widgets import Circuit

Circuit(circuit("RandomNBits(4)"))

Pour plus d’informations, consultez les conventions de circuits Quantum.

Compiler votre travail à l’aide du profil de base

Lorsque vous exécutez des programmes sur le simulateur quantique local, vous pouvez soumettre n’importe quel type de Q# programme. Toutefois, Azure Quantum le matériel targets ne prend pas encore en charge les fonctionnalités complètes requises pour exécuter tous les Q# programmes. Pour compiler et soumettre des programmes à Q#, vous devez configurer votre profil Azure Quantum pour indiquer à target quelles capacités votre matériel Q# prend en charge. Actuellement, il s’agit du profil de base. Pour plus d’informations, consultez Types de profils dans Azure Quantum.

Pour réinitialiser l’interpréteur Q# et compiler votre programme avec le profil de base :

1. Utilisez la init méthode pour définir le profil :

   from qdk import init, TargetProfile
   
   init(target_profile=TargetProfile.Base)
   

2. Étant donné que vous avez réinitialisé l’interpréteur, vous devez réexécuter votre code avec le nouveau profil :

   %%qsharp
   
   operation Random() : Result {
       use q = Qubit();
       H(q);
       let result = M(q);
       Reset(q);
       return result
   }
   
   operation RandomNBits(N: Int): Result[] {
       mutable results = [];
       for i in 0 .. N - 1 {
           let r = Random();
           results += [r];
       }
       return results
   }
   

3. Ensuite, utilisez la compile méthode pour spécifier l’opération ou la fonction qui est le point d’entrée de votre programme. Cela compile votre code au format QIR, qui peut ensuite être envoyé à n’importe quel matériel quantique :

   from qdk.qsharp import compile
   
   MyProgram = compile("RandomNBits(4)")
   

Connectez-vous à Azure Quantum et soumettez votre tâche.

Maintenant que vous avez compilé votre programme dans le format correct, créez un objet Workspace pour vous connecter à Azure Quantum. Utilisez l’ID de ressource de votre Azure Quantum espace de travail pour vous connecter. Copiez votre ID de ressource dans le volet Vue d’ensemble de votre espace de travail sur le Azure portail.

1. Dans une nouvelle cellule, renseignez votre ID de ressource à partir de votre Azure Quantum espace de travail :

   from qdk.azure import Workspace
   
   MyWorkspace = Workspace(resource_id="") # Fill in your resource ID
   

2. Utilisez la get_targets méthode pour afficher le matériel targets disponible dans votre espace de travail :

   MyTargets = MyWorkspace.get_targets()
   print("This workspace's targets:")
   MyTargets
   

3. Sélectionnez :rigetti.sim.qvmtarget

   MyTarget = MyWorkspace.get_targets("rigetti.sim.qvm")
   

4. Enfin, utilisez la submit méthode pour soumettre votre programme avec ses paramètres et afficher les résultats :

   job = MyTarget.submit(MyProgram, "MyQuantumJob", shots=100)
   job.get_results()
   

   {'[0, 1, 1, 1]': 0.08,
    '[1, 1, 0, 0]': 0.1,
    '[0, 0, 1, 0]': 0.04,
    '[0, 1, 0, 0]': 0.05,
    '[1, 0, 1, 0]': 0.05,
    '[1, 0, 0, 0]': 0.07,
    '[0, 1, 0, 1]': 0.07,
    '[1, 0, 1, 1]': 0.07,
    '[0, 0, 0, 0]': 0.08,
    '[1, 1, 1, 0]': 0.05,
    '[0, 0, 0, 1]': 0.1,
    '[0, 0, 1, 1]': 0.04,
    '[0, 1, 1, 0]': 0.09,
    '[1, 0, 0, 1]': 0.04,
    '[1, 1, 1, 1]': 0.05,
    '[1, 1, 0, 1]': 0.02}
   

5. Toutes les propriétés de la tâche sont accessibles dans job.details, par exemple :

   print(job.details)
   print("\nJob name:", job.details.name)
   print("Job status:", job.details.status)
   print("Job ID:", job.details.id)
   

   {'additional_properties': {'isCancelling': False}, 'id': '0150202e-9638-11ee-be2f-b16153380354', 'name': 'MyQuantumJob', 'provider_id': 'rigetti'...}
   Job name: MyQuantumJob
   Job status: Succeeded
   Job ID: 0150202e-9638-11ee-be2f-b16153380354
   

Détails supplémentaires du travail

Le qdk.azure module inclut des méthodes supplémentaires pour afficher des données de travail plus détaillées.

• job.get_results_histogram: cette méthode retourne un dictionnaire des résultats et du nombre de tirs pour chaque mesure unique. Par exemple, les résultats du travail précédent seraient

  print(job.get_results_histogram()) 
  

  {   
      '[0, 1, 1, 1]' : {'Outcome' : [0, 1, 1, 1], 'Count' : 8},  
      '[1, 1, 0, 0]' : {'Outcome' : [1, 1, 0, 0], 'Count' : 10},
      '[0, 0, 1, 0]' : {'Outcome' : [0, 0, 1, 0], 'Count' : 4},
      '[0, 1, 0, 0]' : {'Outcome' : [0, 1, 0, 0], 'Count' : 5},
      '[1, 0, 1, 0]' : {'Outcome' : [1, 0, 1, 0], 'Count' : 5},  
      '[1, 0, 0, 0]' : {'Outcome' : [1, 0, 0, 0], 'Count' : 7},
      '[0, 1, 0, 1]' : {'Outcome' : [0, 1, 0, 1], 'Count' : 7},
      '[1, 0, 1, 1]' : {'Outcome' : [1, 0, 1, 1], 'Count' : 7},
      '[0, 0, 0, 0]' : {'Outcome' : [0, 0, 0, 0], 'Count' : 8},  
      '[1, 1, 1, 0]' : {'Outcome' : [1, 1, 1, 0], 'Count' : 5},
      '[0, 0, 0, 1]' : {'Outcome' : [0, 0, 0, 1], 'Count' : 10},
      '[0, 0, 1, 1]' : {'Outcome' : [0, 0, 1, 1], 'Count' : 4},
      '[0, 1, 1, 0]' : {'Outcome' : [0, 1, 1, 0], 'Count' : 9},  
      '[1, 0, 0, 1]' : {'Outcome' : [1, 0, 0, 1], 'Count' : 4},
      '[1, 1, 1, 1]' : {'Outcome' : [1, 1, 1, 1], 'Count' : 5},
      '[1, 1, 0, 1]' : {'Outcome' : [1, 1, 0, 1], 'Count' : 2}
  }
  

• job.get_results_shots : cette méthode retourne une liste de chaque résultat de capture. Par exemple, les résultats du travail précédent seraient

  print(job.get_results_shots()) 
  

  [ [0, 1, 1, 1], [1, 0, 1, 1], [0, 0, 1, 1], [1, 1, 0, 1], [1, 0, 0, 0], [1, 0, 1, 1], [1, 1, 0, 1], ...]
  

Envoyer Python avec des Q# travaux à Azure Quantum

Découvrez comment utiliser VS Code pour écrire un programme Python qui appelle les opérations Q#, se connecter à Azure avec les commandes Python ou l’interface en ligne de commande Azure (CLI), et envoyer votre travail.

Prérequis

Pour plus d’informations sur l’installation, consultez Configurer l’extensionQDK.

• Un Azure Quantum espace de travail dans votre Azure abonnement. Pour créer un espace de travail, consultez Créer un Azure Quantum espace de travail.
• Un Python environnement avec Python et Pip installé.
• VS Code avec les extensions Azure Quantum Development Kit et Python installées.
• Bibliothèque qdkPython avec l’extra azure .
• Azure CLI avec la dernière Azure Quantum extension installée.

Créer et importer vos Q# opérations

Avec le qdk.qsharp module, vous pouvez stocker vos fonctions et opérations dans Q# des fichiers et créer Q# des projets qui vous permettent d’appeler l’un d’eux à partir de votre Python code. Cela est particulièrement utile lorsque vous devez lancer un programme qui prend des paramètres d’entrée.

1. Suivez les étapes pour créer un Q# projet.

2. Ouvrez un nouveau fichier texte, ajoutez le code suivant Q# qui retourne un nombre spécifié par l’utilisateur de bits aléatoires, puis enregistrez le fichier sous /src dans le répertoire Source.qs de votre projet.

       operation Random() : Result {
       use q = Qubit();
       H(q);
       let result = M(q);
       Reset(q);
       return result
   }
   
   operation RandomNBits(N: Int): Result[] {
       mutable results = [];
       for i in 0 .. N - 1 {
           let r = Random();
           results += [r];
       }
       return results
   }
   

3. Dans le dossier racine du projet (avec le qsharp.json fichier), ouvrez un autre fichier et enregistrez-le sous randomNum.py.

4. Ajoutez le code suivant pour charger les importations requises :

   from qdk import qsharp
   from qdk.azure import Workspace
   

5. Ensuite, ajoutez du code pour définir le dossier racine du Q# projet et tester l’exécution de l’opération target sur le simulateur local. L'opération est appelée par <namespace>.<operation_name( )>, et dans ce cas, vous passez le nombre de bits aléatoires à retourner.

   Remarque

   Comme aucun espace de noms n’a été spécifié dans Source.qs, le compilateur utilise le nom de fichier comme espace de noms par défaut - Source.RandomNBits(). Pour plus d’informations, consultez Projets et espaces de noms implicites.

   qsharp.init(project_root = '../MyProjectRootFolder')
   print(qsharp.eval("Source.RandomNBits(4)"))
   

   [Zero, One, One, Zero]
   

6. Vous pouvez également tester l’opération avec la run méthode, qui reçoit un paramètre supplémentaire shots et retourne les résultats dans une Python liste. Dans randomNum.py, remplacez l’instruction print précédente par les éléments suivants :

   result = qsharp.run("Source.RandomNBits(4)", shots=10)
   for x in result:
       print(x)
   

   [[One, One, One, One],
   [Zero, Zero, One, Zero],
   [One, Zero, Zero, One],
   [Zero, One, Zero, Zero],
   [One, Zero, One, One],
   [One, Zero, One, Zero],
   [One, One, One, Zero],
   [One, One, One, One],
   [Zero, Zero, Zero, One],
   [One, Zero, Zero, One]]
   

Compiler votre travail à l’aide du profil de base

Lorsque vous exécutez des programmes sur le simulateur quantique local, vous pouvez soumettre n’importe quel type de Q# programme. Toutefois, Azure Quantum le matériel targets ne prend pas encore en charge les fonctionnalités complètes requises pour exécuter tous les Q# programmes. Pour compiler des programmes Q# et les soumettre à Azure Quantum, vous devez configurer votre profil target afin d'indiquer à Q# les capacités que votre matériel target prend en charge. Actuellement, il s'agit soit du profil Base, soit du profil Adpative_RI. Pour plus d’informations, consultez Types de profils dans Azure Quantum.

1. Utilisez la init méthode pour définir le profil :

   qsharp.init(project_root = '../MyProjectRootFolder', target_profile=qsharp.TargetProfile.Base)
   

   Remarque

   Étant donné que vous réinitialisez votre qsharp état, vous devez définir à nouveau le project_root paramètre afin que le compilateur sache où trouver l’opération RandomNBits . Cela aurait également pu être effectué à l’étape 5 de la procédure précédente.

2. Utilisez ensuite la compile méthode pour spécifier l’opération ou la fonction qui est le point d’entrée de votre programme. Le programme compilé peut ensuite être envoyé à n’importe quel matériel quantique :

   MyProgram = qsharp.compile("Source.RandomNBits(4)")
   

Connectez-vous à Azure Quantum et soumettez votre tâche.

Vous pouvez vous connecter à Azure Quantum et soumettre votre travail à l'aide d'un objet WorkspacePython, ou vous connecter et soumettre votre travail à l'aide de l'interface en ligne de commande Azure. L’utilisation Azure de l’interface CLI nécessite d’enregistrer le programme compilé en tant que fichier texte et de soumettre ce fichier à l’aide d’une commande CLI.