Bien démarrer avec les programmes Q# et Visual Studio Code
Dans cet article, vous trouverez les étapes permettant d’utiliser VC Code pour créer et envoyer des travaux d’informatique quantique Q#, Jupyter Notebook ou Python à Azure Quantum à l’aide de VS 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 moderne 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 ouvrez VS Code sur le web.
- Dernière version de l’extension du Kit de développement Azure Quantum .
Charger un exemple de programme Q#
Dans VS Code, sélectionnez Fichier > Nouveau fichier texte et enregistrez le fichier sous RandomNum.qs.
Ouvrez RandomNum.qs et tapez
sample
, puis sélectionnez Exemple de bits aléatoires dans la liste des options et enregistrez le fichier.
Notes
Vous pouvez également ouvrir votre propre fichier Q#. Si vous exécutez un programme Q# plus ancien et que vous rencontrez des erreurs, consultez Test et débogage ou Migration de vos programmes vers le QDK moderne.
Exécuter un programme Q#
Pour tester l’exécution de votre programme localement sur le simulateur intégré, cliquez sur Exécuter dans la liste des commandes ci-dessous
@EntryPoint()
ou appuyez sur Ctrl+F5. Votre sortie s’affiche dans la console de débogage.Pour déboguer votre programme avant de l’envoyer à Azure Quantum, cliquez sur Déboguer dans la liste des commandes ci-dessous
@EntryPoint()
ou appuyez sur F5. Utilisez les contrôles de débogage en haut pour effectuer un pas à pas détaillé, dans et hors du code. Pour plus d’informations sur le débogage de programmes Q#, consultez Test et débogage.
Tracer 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 « plans ». 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.
Sélectionnez Affichage -> Palette de commandes et tapez « histogramme » qui doit afficher l’option Q# : Exécuter le fichier et afficher l’histogramme . Vous pouvez également cliquer sur Histogramme dans la liste des commandes ci-dessous
@EntryPoint()
. Sélectionnez cette option pour ouvrir la fenêtre d’histogramme Q#.Entrez un certain nombre de plans pour exécuter le programme, par exemple 100 plans, puis appuyez sur Entrée. L’histogramme s’affiche dans la fenêtre d’histogramme Q#.
Cliquez sur l’icône des paramètres en haut à gauche pour afficher les options.
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 %.
Conseil
Vous pouvez effectuer un zoom sur l’histogramme à l’aide de la roulette de défilement de la souris ou d’un mouvement de pavé tactile. Lorsque vous effectuez un zoom avant, vous pouvez parcourir le graphique en appuyant sur « Alt » pendant le défilement.
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 envoyer un travail au simulateur Rigetti.
Sélectionnez Affichage -> Palette de commandes et tapez Q# : Se connecter à un espace de travail Azure Quantum. Appuyez sur Entrée.
Sélectionnez Compte Azure, puis suivez les invites pour vous connecter à votre annuaire, abonnement et espace de travail préférés.
Notes
Si vous avez un chaîne de connexion, vous pouvez sélectionner 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.
Une fois que vous êtes connecté, dans le volet Explorer, développez Espaces de travail quantiques.
Développez votre espace de travail et développez le fournisseur Rigetti .
Notes
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.
Sélectionnez rigetti.sim.qvm comme votre target.
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.
Ajoutez un nom pour identifier le travail.
Ajoutez le nombre de captures ou le nombre de fois où le programme est exécuté.
Appuyez sur Entrée pour envoyer le travail. Le status de travail s’affiche en bas de l’écran.
Développez Travaux et pointez sur votre travail, ce qui affiche les heures et les status de votre travail.
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 les 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 Jupyter Notebook Q# à Azure Quantum. Les étapes décrites dans cet article s’appliquent également aux notebooks Jupyter sur votre serveur Jupyter local ou à vos notebooks dans le portail Azure Quantum.
Prérequis
Pour plus d’informations sur l’installation, consultez Installation du QDK moderne 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, Python et les extensions Jupyter installées .
- Azure Quantum
qsharp
etazure-quantum
packages, et leipykernel
package.
Exécuter et tester votre programme dans le simulateur local
Dans VS Code, sélectionnez Afficher > la palette de commandes, puis Créer : nouveau Jupyter Notebook.
En haut à droite, VS Code détecte et affiche la version de Python et l’environnement Python virtuel qui a été 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 Notebooks Jupyter dans VS Code pour plus d’informations sur l’installation.
Dans la première cellule du notebook, exécutez
import qsharp import azure.quantum
- Le
qsharp
module active la%%qsharp
commande magic qui vous permet d’entrer du code Q# directement dans une cellule. - Le
azure-quantum
module fournit une connectivité à votre espace de travail Azure Quantum.
Notes
Si le noyau
ipykernel
Jupyter Python n’est pas détecté, VS Code vous invite à l’installer.- Le
Ajoutez une autre cellule et entrez ce code Q# qui retourne un nombre de bits aléatoires spécifié par l’utilisateur :
%%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 }
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]
Pour exécuter votre programme sur le simulateur local, utilisez la
run
méthode . Spécifiez le ou leshots
nombre de fois où exécuter le programme, et le simulateur retourne les résultats sous la forme d’une 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]]
Compiler votre travail à l’aide du profil de base
Lorsque vous exécutez des programmes sur le simulateur quantique local, vous pouvez envoyer n’importe quel type de programme Q#. Toutefois, le matériel targets Azure Quantum ne prend pas encore en charge toutes les fonctionnalités 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 à 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 :
Utilisez la
init
méthode pour définir le profil :qsharp.init(target_profile=qsharp.TargetProfile.Base)
Depuis 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 }
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 soumis à 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 le Portail Azure.
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" )
Utilisez la
get_targets
méthode pour voir le matériel targets disponible dans votre espace de travail :MyTargets = MyWorkspace.get_targets() print("This workspace's targets:") MyTargets
Sélectionnez :
rigetti.sim.qvm
targetMyTarget = MyWorkspace.get_targets("rigetti.sim.qvm")
Enfin, utilisez la
submit
méthode pour envoyer votre programme avec ses paramètres et afficher les résultats :job = MyTarget.submit(MyProgram, "MyQuantumJob", shots=100) job.get_results()
{'Histogram': ['[0, 0, 0, 0]', 0.3, '[1, 0, 0, 0]', 0.1, '[1, 1, 1, 1]', 0.3, '[0, 1, 1, 1]', 0.3]}
Toutes les propriétés du travail 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
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#, vous 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 moderne 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ées.
- Azure Quantum
qsharp
etazure-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’entre 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.
Suivez les étapes pour créer un projet Q#.
Ouvrez un nouveau fichier texte, ajoutez le code Q# suivant qui retourne un nombre de bits aléatoires spécifié par l’utilisateur, puis enregistrez le fichier dans votre projet sous la forme
source.qs
.Notes
Notez que ce code Q# n’a pas de
@EntryPoint
fonction comme un programme Q# (voir Soumission de travaux Q# à Azure Quantum), mais qu’il nécessite un espace de noms, contrairement à un Jupyter Notebook (voir Envoi de Jupyter Notebook travaux à Azure Quantum).namespace Sample { 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 } }
Dans le même dossier, ouvrez un autre fichier et enregistrez-le sous la forme
randomNum.py
.Ajoutez le code suivant pour importer les
qsharp
modules et .azure.quantum
import qsharp import azure.quantum
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 transmettez le nombre de bits aléatoires à retourner.
qsharp.init(project_root = '/MyProjectRootFolder') print(qsharp.eval("Sample.RandomNBits(4)"))
[Zero, One, One, Zero]
Vous pouvez également tester l’opération avec la
run
méthode, qui passe un paramètre supplémentaireshots
et retourne les résultats dans une liste Python. DansrandomNum.py
, remplacez l’instruction print précédente par ce qui suit :result = qsharp.run("Sample.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 envoyer n’importe quel type de programme Q#. Toutefois, le matériel targets Azure Quantum ne prend pas encore en charge toutes les fonctionnalités 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 à Q# les fonctionnalités prises en charge par votre target matériel. Actuellement, il s’agit du profil de base. Pour plus d’informations, consultez Types de profils dans Azure Quantum.
Notes
Pour les programmes Q# uniquement dans VS Code, VS Code définit automatiquement le profil de base.
Utilisez la
init
méthode pour définir le profil :qsharp.init(target_profile=qsharp.TargetProfile.Base)
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 soumis à n’importe quel matériel quantique :MyProgram = qsharp.compile("Sample.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 envoyer votre travail à l’aide d’Azure CLI. Pour utiliser Azure CLI, vous devez enregistrer le programme compilé en tant que fichier texte et envoyer ce fichier à l’aide d’une commande CLI.
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 le Portail Azure.
Ajoutez le code suivant à
randomNum.py
, en remplissant votre ID de ressource et votre emplacement à partir de votre espace de travail Azure Quantum :workspace = azure.quantum.Workspace( resource_id = "MyResourceID", location = "MyLocation" )
Utilisez la
get_targets
méthode pour afficher le matériel targets disponible dans votre espace de travail :MyTargets = workspace.get_targets() print("This workspace's targets:") for x in MyTargets: print(x)
Sélectionnez :
rigetti.sim.qvm
targetMyTarget = workspace.get_targets("rigetti.sim.qvm")
Enfin, utilisez la
submit
méthode pour envoyer votre programme avec ses paramètres. Les résultats du travail sont retournés sous la forme d’un dictionnaire Python.job = MyTarget.submit(MyProgram, "MyPythonJob", shots=100) results = job.get_results() print("\nResults: ", results)
Pour extraire uniquement les valeurs et les afficher :
resultList = results.get("Histogram") for x in resultList: print(x)
[0, 0, 0, 0] 0.3 [1, 0, 0, 0] 0.1 [1, 1, 1, 1] 0.3 [0, 1, 1, 1] 0.3
Toutes les propriétés du travail 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': '0fc396d2-97dd-11ee-9958-6ca1004ff31f', 'name': 'MyPythonJob', 'provider_id': 'rigetti'...} Job name: MyPythonJob Job status: Succeeded Job ID: fc396d2-97dd-11ee-9958-6ca1004ff31f
Étapes suivantes
Commentaires
https://aka.ms/ContentUserFeedback.
Bientôt disponible : Tout au long de l’année 2024, nous abandonnerons progressivement le mécanisme de retour d’information GitHub Issues pour le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez :Soumettre et afficher des commentaires pour