Bien démarrer avec les programmes Q# et Visual Studio Code

Article
04/17/2024

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 et azure-quantum packages, et le ipykernel 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.

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 le shotsnombre 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.qvmtarget

MyTarget = 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 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’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émentaire shots et retourne les résultats dans une liste Python. Dans randomNum.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.

Utilisation de Python
Utilisation de l’interface de ligne de commande Azure (CLI)

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.qvmtarget

MyTarget = 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

Pour envoyer un travail à Azure Quantum avec Azure CLI, vous devez envoyer un fichier physique du programme que vous venez de compiler.

Ajoutez au code suivant à votre randomNum.py fichier. Cela ouvre un fichier texte et écrit votre programme compilé au format approprié.
```
file = open("compiled_output.txt", "w")
file.write(MyProgram._ll_str)
file.close()
```
Pour envoyer le travail à Azure Quantum, connectez-vous avec Azure CLI :
```
az login
```
Vérifiez que vous exécutez la dernière version de l’extension Azure CLI quantum :
```
az extension add --upgrade --name quantum
```
Spécifiez l’abonnement à utiliser parmi ceux associés à votre compte Azure. Vous pouvez aussi trouver votre ID d’abonnement dans la vue d’ensemble de votre espace de travail dans le portail Azure.
```
az account set -s <MySubscriptionID>
```
Affichez vos espaces de travail disponibles avec :
```
az quantum workspace list
```
Vous pouvez utiliser quantum workspace set afin de sélectionner l’espace de travail par défaut qui doit être utilisé pour lister et envoyer des travaux.
```
az quantum workspace set \
   -g <MyResourceGroup> \
   -w <MyWorkspace> \
   -l <MyLocation> \
   -o table
```
Affichez le disponible targets dans votre espace de travail avec :
```
az quantum target list -o table
```
Envoyez votre travail à l’aide de la job submit commande .
- --target-id peut être n’importe quel target. Pour cet exemple, utilisez rigetti.sim.qvmtarget.
- --job-name peut être n’importe quelle chaîne.
- --job-input-format est toujours qir.v1.
- --job-input-file est le nom du fichier texte que vous avez créé à l’étape 1.
- --entry-point est toujours ENTRYPOINT__main
```
az quantum job submit \
    --target-id rigetti.sim.qvm \
    --job-name MyQuantumJob \
    --job-input-format qir.v1 \
    --job-input-file compiled_output.txt \
    --entry-point ENTRYPOINT__main
```

Pour case activée le status du travail, copiez l’ID de la sortie de la dernière étape et utilisez la job show commande :

az quantum job show --job-id b0012975-744a-4405-970e-3d8dc4afb2c0 -o table

Name      Id                                    Status     Target           Submission time                   Completion time                  
--------  ------------------------------------  ---------  ---------------  --------------------------------  -------------------------------- 
MyQuantumJob  b2f07cc4-b49b-40b0-b63b-9a4885e5fef5  Succeeded  rigetti.sim.qvm  2023-12-11T05:33:23.187773+00:00  2023-12-11T05:33:29.252742+00:00

Pour afficher la sortie du travail, utilisez la job output commande :

az quantum job output --job-id b0012975-744a-4405-970e-3d8dc4afb2c0 -o table

Result        Frequency
------------  -----------  ----------------------
[0, 1, 1, 1]  1.00000000   |████████████████████|

Bien démarrer avec les programmes Q# et Visual Studio Code

Envoi de travaux Q# à Azure Quantum

Prérequis

Charger un exemple de programme Q#

Exécuter un programme Q#

Tracer l’histogramme de fréquence

Se connecter à Azure Quantum et envoyer votre travail

Envoi de travaux Jupyter Notebooks à Azure Quantum

Prérequis

Exécuter et tester votre programme dans le simulateur local

Compiler votre travail à l’aide du profil de base

Se connecter à Azure Quantum et envoyer votre travail

Envoi de Python avec des travaux Q# à Azure Quantum

Prérequis

Créer et importer vos opérations Q#

Compiler votre travail à l’aide du profil de base

Se connecter à Azure Quantum et envoyer votre travail

Étapes suivantes

Commentaires

Commentaires

Ressources supplémentaires