Comment envoyer des programmes Q# avec Visual Studio Code

Envoi de travaux Q# à Azure Quantum

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

Prérequis

Pour plus d’informations sur l’installation, consultez Installation du QDK sur VS Code.

• Un espace de travail Azure Quantum dans votre abonnement Azure. Pour créer un espace de travail, consultez Créer un espace de travail Azure Quantum.
• La dernière version de Visual Studio Code ou ouvrir VS Code sur le web.
• La dernière version de l’extension Kit de développement Azure Quantum.

Charger un exemple de programme Q#

1. Dans VS Code, sélectionnez Fichier > nouveau fichier texte et enregistrez le fichier sous 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 sortie s’affiche dans la console de débogage.

2. Pour déboguer votre programme avant de l’envoyer à 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. Utilisez les contrôles de débogage au-dessus pour parcourir, entrer et sortir du code. Pour plus d’informations sur le débogage de programmes Q#, consultez Test et 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 Affichage -> Palette de commandes et tapez « histogramme » qui doit afficher l’option Q# : Exécuter le fichier et afficher l’option d’histogramme . Vous pouvez également cliquer sur Histogramme dans la liste des commandes en regard de 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 appliquées à eux. Pour plus d’informations, consultez diagrammes de circuit quantum dans Visual Studio Code.

1. Sélectionnez Affichage - Palette de commandes et tapez « circuit » qui doit afficher l’option Q# : Afficher le circuit.> Vous pouvez également cliquer sur 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 circuit Q#. 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.

   

Se connecter à Azure Quantum et envoyer votre travail

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

1. Sélectionnez Affichage -> Palette de commandes et tapez Q# : Connectez-vous à un espace de travail Azure Quantum. Appuyez sur Entrée.

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

   Remarque

   Si vous avez un chaîne de connexion, vous pouvez sélectionner la chaîne de connexion et coller le chaîne de connexion correspondant à votre espace de travail Azure Quantum. 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 Les espaces de travail Quantum.

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

   Remarque

   En cas de problème de connexion à Azure Quantum, une icône d’avertissement s’affiche en regard 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 à envoyer le programme Q# actuel. Si vous obtenez une fenêtre contextuelle, sélectionnez Modifier le profil QIR target et continuez.

   

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 Travaux et survolez votre travail, ce qui affiche les heures et l’état de votre travail.

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

    

Envoi de travaux Jupyter Notebooks à Azure Quantum

Découvrez comment utiliser VS Code pour exécuter, déboguer et envoyer un notebook Jupyter Q# à Azure Quantum. Les étapes décrites dans cet article s’appliquent également aux notebooks Jupyter locaux sur votre serveur Ou notebooks Jupyter local dans le portail Azure Quantum.

Prérequis

Pour plus d’informations sur l’installation, consultez Installation du QDK sur VS Code.

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

• Un environnement Python avec Python et Pip installés.

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

• Azure Quantum qsharp, qsharp-widgetset azure-quantum les packages, et le ipykernel package.

  python -m pip install --upgrade qsharp qsharp-widgets azure-quantum ipykernel
  

Exécuter et tester votre programme dans le simulateur local

1. Dans VS Code, sélectionnez Affichage > Palette de commandes, puis sélectionnez Créer : Notebook Jupyter.

2. En haut à droite, VS Code détecte et affiche la version de Python et l’environnement Python virtuel sélectionné pour le notebook. Si vous avez plusieurs environnements Python, 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 Notebooks dans VS Code pour obtenir des informations de configuration.

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

   import qsharp
   import azure.quantum
   

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

   Remarque

   Si le noyau ipykernel Jupyter Python n’est pas détecté, VS Code vous invite à l’installer.

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

   Remarque

   Notez que dès que vous tapez dans la commande %%qsharpmagic, la cellule du bloc-notes change le type de Python en 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();
           set results += [r];
       }
       return results
   }
   

5. Pour tester votre opération, vous pouvez utiliser la eval méthode, qui peut appeler n’importe quelle opération Q# 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 liste Python.

   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 qsharp-widgets package. Ce package fournit un widget qui affiche un diagramme de circuit quantique en tant qu’image SVG. Pour plus d’informations, consultez diagrammes de circuits Quantum avec jupyter Notebooks.

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

from qsharp_widgets import Circuit

Circuit(qsharp.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 programme Q#. Toutefois, le matériel targets Azure Quantum ne prend pas encore en charge les fonctionnalités complètes requises pour exécuter tous les programmes Q#. Pour compiler et envoyer des programmes Q# à Azure Quantum, vous devez définir votre target profil pour indiquer aux Q# quelles fonctionnalités votre target matériel 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 :

   qsharp.init(target_profile=qsharp.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();
           set 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 :

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

Se connecter à Azure Quantum et envoyer votre travail

Maintenant que votre programme est compilé dans le format approprié, créez un azure.quantum.Workspace objet pour vous connecter à Azure Quantum. Vous allez utiliser l’ID de ressource de votre espace de travail Azure Quantum pour vous connecter. L’ID de ressource et l’emplacement peuvent être copiés à partir de la page vue d’ensemble de votre espace de travail dans la Portail Azure.

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

   MyWorkspace = azure.quantum.Workspace(
       resource_id = "MyResourceID",
       location = "MyLocation"
   )
   

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 du travail sont accessibles, job.detailspar 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 azure.quantum package Python 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], ...]
  

Envoi de Python avec des travaux Q# à Azure Quantum

Découvrez comment utiliser VS Code pour écrire un programme Python qui appelle des opérations Q#, se connecter à Azure à l’aide des commandes Python ou d’Azure CLI et envoyer votre travail.

Prérequis

Pour plus d’informations sur l’installation, consultez Installation du QDK sur VS Code.

• Un espace de travail Azure Quantum dans votre abonnement Azure. Pour créer un espace de travail, consultez Créer un espace de travail Azure Quantum.
• Un environnement Python avec Python et Pip installés.
• VS Code avec le Kit de développement Azure Quantum et l’extension Python installés.
• Azure Quantum qsharp et azure-quantum packages.
• Azure CLI avec la dernière extension Azure Quantum installée.

Créer et importer vos opérations Q#

Avec le qsharp package, vous pouvez stocker vos fonctions et opérations dans des fichiers Q# et créer des projets Q# qui vous permettent d’appeler l’un d’eux à partir de votre code Python. 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 projet Q#.

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

   
       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();
           set results += [r];
       }
       return results
   }
   

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

4. Ajoutez le code suivant pour importer les modules et azure.quantum les qsharp modules.

   import qsharp
   import azure.quantum
   

5. Ensuite, ajoutez du code pour définir le dossier racine du projet Q# et testez l’opération target sur le simulateur local. L’opération est appelée par <espace de noms.<>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 réussit un paramètre supplémentaire shots et retourne les résultats dans une liste Python. 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 programme Q#. Toutefois, le matériel targets Azure Quantum ne prend pas encore en charge les fonctionnalités complètes requises pour exécuter tous les programmes Q#. Pour compiler et envoyer des programmes Q# à Azure Quantum, vous devez définir votre target profil pour indiquer aux Q# les fonctionnalités prises en charge par votre target matériel. Actuellement, c’est le ou Adpative_RI le Base profil. 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 état qsharp, 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)")
   

Se connecter à Azure Quantum et envoyer votre travail

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