Comment envoyer des programmes Q# avec Visual Studio Code

Article
10/29/2024

Découvrez comment utiliser Visual Studio Code pour créer et envoyer des programmes Q# à du matériel quantique réel. Vous pouvez soumettre des travaux d’informatique quantique à Azure Quantum en tant que programme Q# autonome, combiner Q# avec Python dans un projet Q# et exécuter un notebook Jupyter.

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#

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 l’exemple Bit aléatoire dans la liste des options et enregistrez le fichier.

Remarque

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.

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

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#.
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#.
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 avant sur l’histogramme à l’aide de la roulette de défilement de la souris ou d’un mouvement de trackpad. Lorsque vous effectuez un zoom avant, vous pouvez parcourir le graphique en appuyant sur « Alt » lors du défilement.

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.

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

Sélectionnez Affichage -> Palette de commandes et tapez Q# : Connectez-vous à un espace de travail Azure Quantum. Appuyez sur Entrée.
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.
Une fois connecté, dans le volet Explorateur , développez Les espaces de travail Quantum.
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.
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 que le programme est exécuté.
Appuyez sur Entrée pour envoyer le travail. L’état du travail s’affiche en bas de l’écran.
Développez Travaux et survolez votre travail, ce qui affiche les heures et l’état de votre travail.
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

Dans VS Code, sélectionnez Affichage > Palette de commandes, puis sélectionnez Créer : Notebook Jupyter.
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.
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.

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();
        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 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)"))

Capture d’écran de Jupyter Notebook montrant comment visualiser le circuit pour une opération Q#.

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 :

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

qsharp.init(target_profile=qsharp.TargetProfile.Base)

É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
}

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.

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 afficher 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 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}

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.

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

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

Dans le dossier racine du projet (avec le fichier qsharp.json ), ouvrez un autre fichier et enregistrez-le sous randomNum.py.
Ajoutez le code suivant pour importer les modules et azure.quantum les qsharp modules.
```
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 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]
```

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.

Remarque

Pour les programmes Q# uniquement dans VS Code, VS Code définit automatiquement le Base profil.

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

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 soumettre votre programme avec ses paramètres. Les résultats du travail sont retournés en tant que dictionnaire Python.
```
job = MyTarget.submit(MyProgram, "MyPythonJob", shots=100)
results = job.get_results()
print("\nResults: ", results)
```

Pour extraire uniquement les valeurs et les afficher :

for x in results:
    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, 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': '0fc396d2-97dd-11ee-9958-6ca1004ff31f', 'name': 'MyPythonJob', 'provider_id': 'rigetti'...}
Job name: MyPythonJob
Job status: Succeeded
Job ID: fc396d2-97dd-11ee-9958-6ca1004ff31f

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

results = job.get_results_histogram()
for x in results.items():
    print(x)

{   
    '[0, 0, 0, 0]' : {'Outcome' : [0, 0, 0, 0], 'Count' : 30},  
    '[1, 0, 0, 0]' : {'Outcome' : [1, 0, 0, 0], 'Count' : 10},
    '[1, 1, 1, 1]' : {'Outcome' : [1, 1, 1, 1], 'Count' : 30},
    '[0, 1, 1, 1]' : {'Outcome' : [0, 1, 1, 1], 'Count' : 30}
}

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, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1], [1, 1, 1, 1], [1, 0, 0, 0], [0, 1, 1, 1], [0, 0, 0, 0], ...]
```

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

Ajoutez le 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 à 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 vérifier l’état du travail, copiez l’ID à partir 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   |████████████████████|

Partager via

Comment envoyer des programmes Q# avec Visual Studio Code

Envoi de travaux Q# à Azure Quantum

Prérequis

Charger un exemple de programme Q#

Exécuter un programme Q#

Visualiser l’histogramme de fréquence

Visualiser le circuit quantique

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

Visualiser le circuit quantique

Compiler votre travail à l’aide du profil de base

Se connecter à Azure Quantum et envoyer votre travail

Détails supplémentaires du 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

Détails supplémentaires du travail

Commentaires

Ressources supplémentaires

Partager via

Comment envoyer des programmes Q# avec Visual Studio Code

Envoi de travaux Q# à Azure Quantum

Prérequis

Charger un exemple de programme Q#

Exécuter un programme Q#

Visualiser l’histogramme de fréquence

Visualiser le circuit quantique

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

Visualiser le circuit quantique

Compiler votre travail à l’aide du profil de base

Se connecter à Azure Quantum et envoyer votre travail

Détails supplémentaires du 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

Détails supplémentaires du travail

Contenu connexe

Commentaires

Ressources supplémentaires