Développer des programmes OpenQASM dans le Microsoft Quantum Development Kit

Le Microsoft Quantum Development Kit (QDK) fournit différents environnements de développement pour les programmes OpenQASM avec l’intégration Azure Quantum. Dans cet article, vous allez apprendre à développer et exécuter OpenQASM du code dans :

  • Extension QDK dans Visual Studio Code (VS Code)
  • Package QDK Python dans Jupyter Notebook.

Les outils de développement comme CodeLends, IntelliSense, la saisie semi-automatique de code et le débogage de point d’arrêt sont disponibles uniquement dans l’extension VS Code. D’autres fonctionnalités sont disponibles uniquement dans le package Python. Par exemple, vous pouvez passer des éléments appelables Q# et OpenQASM sous forme d’objets Python, et compiler en QIR des programmes OpenQASM qui acceptent des entrées.

Conditions préalables

  • Installer la dernière version de VS Code

  • Pour travailler directement avec les fichiers OpenQASM, installez la dernière version de l’extension QDK dans VS Code.

  • Pour utiliser OpenQASM dans Python et Jupyter Notebook, installez la dernière version de l’extension Python et l’extension Jupyter dans VS Code.

  • Installez la dernière version du qdk package Python avec les jupyter éléments supplémentaires :

    pip install --upgrade "qdk[jupyter]"

Travaillez avec OpenQASM dans VS Code en utilisant l'extension QDK

Pour écrire OpenQASM code dans VS Code, ouvrez un projet Q# et créez un fichier OpenQASM avec une extension .qasm. Le système QDK reconnaît automatiquement le fichier .qasm comme OpenQASM, et les fonctionnalités QDK pour OpenQASM sont disponibles au fur et à mesure que vous rédigez votre code.

Les fonctionnalités suivantes QDK sont disponibles pour les programmes OpenQASM dans VS Code:

  • Complétion de code
  • Lentilles de code (Run, Histogram, Estimate, Debug et Circuit)
  • Mise en surbrillance de la syntaxe et fonctions de base de syntaxe, telles que l'appariement des accolades
  • Vérification des erreurs dans les OpenQASM fichiers sources
  • Débogage par points d’arrêt et exécution de scripts pour les fichiers source OpenQASM
  • Débogage avec génération de circuits en direct
  • Intégration avec Azure Quantum pour la soumission de tâches quantiques

Pour exécuter votre programme OpenQASM à partir de VS Code, vous pouvez utiliser le simulateur local QDK ou envoyer le code en tant que travail à Azure Quantum.

Exécuter votre code sur le QDK simulateur local

Pour exécuter votre code OpenQASM sur le simulateur quantique local sparse dans VS Code, ouvrez un fichier .qasm, puis sélectionnez la commande Exécuter dans l’indicateur CodeLens au début du fichier. La sortie de votre programme s’affiche dans le VS Code terminal.

Remarque

Le QDK tente automatiquement de définir un profil QIR target qui prend en charge votre programme. Si le profil QIR target ne prend pas en charge les opérations dans votre programme, vous obtenez des erreurs de compilateur lorsque vous exécutez votre OpenQASM code. Pour plus d’informations sur les profils target, consultez Types de profils target dans Azure Quantum.

Exemples de programmes préinstallés

Le QDK est fourni avec plusieurs exemples intégrés d’algorithmes quantiques pour OpenQASM. Pour essayer les exemples d’algorithmes, entrez sample dans un fichier .qasm vide. Une liste d’achèvement s’affiche qui contient les exemples d’algorithmes. Choisissez un exemple, puis exécutez le code généré.

Déboguer localement dans VS Code

Le QDK inclut un débogueur pour OpenQASM. Le débogueur prend en charge le débogage de style point d’arrêt et peut afficher l’état du programme.

Pour démarrer le débogueur, sélectionnez la commande Déboguer dans le code lens.

En mode débogage, vous pouvez définir des points d’arrêt dans votre code pour vous aider à déboguer. L’état de votre programme s’affiche dans le volet RUN AND DEBUG . Par exemple, vous pouvez afficher les états de vos variables locales et les états qubits.

Exécutez votre code sur Azure Quantum

Pour exécuter des OpenQASM programmes sur Azure Quantumtargets, vous devez disposer d’un Azure Quantum espace de travail. Pour créer un Azure Quantum espace de travail, consultez Créer un Azure Quantum espace de travail.

Pour soumettre des travaux OpenQASM à Azure Quantum à partir de VS Code, vous devez vous connecter à l’espace de travail Azure Quantum. Pour vous connecter à votre espace de travail à partir de VS Code, consultez Se connecter à l’aide d’une chaîne de connexion.

Pour soumettre une OpenQASM tâche à Azure Quantum depuis VS Code, procédez comme suit :

  1. Ouvrez le qasm fichier qui contient votre programme dans VS Code.
  2. Sélectionnez l’icône Microsoft Quantum pour ouvrir le panneau Microsoft Quantum.
  3. Développez la liste déroulante QUANTUM WORKSPACES et sélectionnez votre espace de travail.
  4. Développez la liste déroulante Fournisseurs et choisissez un fournisseur, puis choisissez celui target sur lequel vous souhaitez exécuter votre travail. Par exemple, soumettez votre tâche au rigetti.svm.simtarget pour exécuter votre programme sur le simulateur backend de Rigetti. Pour plus d’informations sur le fournisseur et target la disponibilité, consultez Ajouter ou supprimer un fournisseur dans un espace de travail existant.
  5. Sélectionnez l’icône de lecture en regard du nom de target.
  6. Pour soumettre la tâche, saisissez des valeurs pour les requêtes Nom de la tâche et Nombre de prises.

Pour afficher les heures et l’état d’un travail, développez la liste déroulante Travaux et pointez sur le nom du travail. Pour télécharger les résultats du travail, sélectionnez l’histogramme ou les icônes de texte en regard du nom du travail.

Utiliser OpenQASM dans Python et Jupyter Notebook

Avec le package Python QDK, vous pouvez exécuter directement du code OpenQASM et transmettre des circuits OpenQASM aux programmes Q# sous forme d’opérations. Écrivez votre code OpenQASM en tant que chaîne Python, puis utilisez cette chaîne pour exécuter, importer ou compiler votre code OpenQASM dans l’environnement Python.

Exécutez OpenQASM directement dans Python

Pour exécuter OpenQASM du code directement, utilisez la fonction run du module qdk.openqasm. Par exemple, le code suivant exécute 10 tirs sur le simulateur local d’un programme simple OpenQASM avec bruit :

from qdk import BitFlipNoise
from qdk.openqasm import run

qasm_code = """
    include "stdgates.inc";
    qubit[2] q;
    reset q;
    h q[0];
    cx q[0], q[1];
    bit c = measure q[1];
    """

results = run(qasm_code, shots=10, noise=BitFlipNoise(0.1))
print(results)

Appeler un OpenQASM programme dans Q#

Vous pouvez utiliser la fonction import_openqasm pour stocker un programme OpenQASM en tant qu’objet Python, puis appeler cet objet plus loin dans votre code de Python. Par exemple, la cellule suivante stocke un circuit OpenQASM dans un objet Python appelé bell :

from qdk import qsharp
from qdk.openqasm import import_openqasm

qasm_code = """
    include "stdgates.inc";
    qubit[2] q;
    reset q;
    h q[0];
    cx q[0], q[1];
    bit c = measure q[1];
    """

import_openqasm(qasm_code, name="bell")

Quand bell il fait partie de votre environnement, vous pouvez l’exécuter directement à partir d’une cellule Q# :

%%qsharp

use qs = Qubit[2];
bell(qs)

Vous pouvez également utiliser la fonctionnalité du package QDK, telle que la simulation bruyante, le rendu de circuit bell et la génération de code.

Programmes OpenQASM paramétrables

La cellule suivante crée un circuit OpenQASM qui prend un angle theta comme entrée, puis appelle le circuit en tant que fonction Python :

from qdk.openqasm import import_openqasm, ProgramType

qasm_code = """
    include "stdgates.inc";
    input float theta;
    qubit[2] q;
    rx(theta) q[0];
    rx(-theta) q[1];
    bit[2] c;
    c = measure q;
    """

import_openqasm(qasm_code, name="parameterized_circuit", program_type=ProgramType.File)

from qdk.code.qasm_import import parameterized_circuit

parameterized_circuit(1.57)

Passer un programme OpenQASM à Q#

Avec le QDK package Python, vous pouvez passer directement un OpenQASM programme à un programme Q#. Par exemple, le code suivant crée un OpenQASM programme appelé Entangle , puis utilise Entangle comme opération dans un programme Q# :

from qdk.openqasm import import_openqasm
from qdk import qsharp

qasm_code = """
    include "stdgates.inc";
    qubit[2] qs;
    h qs[0];
    cx qs[0], qs[1];
    """

import_openqasm(qasm_code, name="Entangle")

qsharp.eval("{ use qs = Qubit[2]; Entangle(qs); MResetEachZ(qs) }")

Lorsque vous importez Q# et importez des programmes OpenQASM dans un environnement Python avec qsharp.eval et import_openqasm, ces programmes deviennent des objets Python que vous pouvez appeler dans votre code Python. Par exemple, le code suivant crée un programme Q# appelé TestAntiCorrelation et transmet le EntangleOpenQASM programme à TestAntiCorrelation:

qsharp.eval("""
    operation TestAntiCorrelation(entangler : Qubit[] => Unit) : Result[] {
        use qs = Qubit[2];
        X(qs[1]);
        entangler(qs);
        MResetEachZ(qs)
    }
    """)

from qdk.code import Entangle, TestAntiCorrelation

TestAntiCorrelation(Entangle)

Compiler des programmes OpenQASM en QIR

Vous pouvez compiler du OpenQASM code en représentation intermédiaire quantique (QIR) avec la fonction compile.

Par exemple, la cellule suivante compile le OpenQASM code d’un circuit paramétré en QIR :

from qdk import TargetProfile
from qdk.openqasm import import_openqasm, ProgramType
from qdk import qsharp

qsharp.init(target_profile=TargetProfile.Base)

qasm_code = """
    include "stdgates.inc";
    input float theta;
    qubit[2] q;
    rx(theta) q[0];
    rx(-theta) q[1];
    bit[2] c;
    c = measure q;
    """

import_openqasm(qasm_code, name="parameterized_circuit", program_type=ProgramType.File)

from qdk.code.qasm_import import parameterized_circuit

bound_compilation = qsharp.compile(parameterized_circuit, 1.57)
print(bound_compilation)

Remarque

Pour compiler OpenQASM des programmes qui prennent des variables d’entrée dans QIR, vous devez utiliser le QDK package Python. Vous ne pouvez pas compiler de programmes paramétrables OpenQASM en QIR à l’aide de l’extension QDK dans VS Code.

Envoyer des OpenQASM programmes à Azure Quantum

Pour soumettre un programme OpenQASM pour qu’il s’exécute sur un Azure Quantumtarget, compilez le code OpenQASM en QIR, puis soumettez le QIR pour exécution sur Azure Quantum.

Par exemple, compilez un circuit d’intrication simple en QIR.

from qdk.openqasm import compile

qasm_code = """
    include "stdgates.inc";
    bit[2] c;
    qubit[2] q;
    h q[0];
    cx q[0], q[1];
    c = measure q;
"""

qir_compilation = compile(qasm_code)

Pour exécuter une tâche QIR vers Azure Quantum, connectez-vous à votre espace de travail quantique et soumettez la tâche à l’une des ressources disponibles targets dans votre espace de travail. Par exemple, soumettez le QIR d’enchevêtrement pour l’exécuter sur le simulateur backend d’IonQ.

from qdk.azure import Workspace 

workspace = Workspace(resource_id="") # Add the resource ID of your workspace

target = workspace.get_targets('ionq.simulator')
job = target.submit(qir_compilation, shots=100)

print("Job submitted. Waiting for results...")

results = job.get_results()
print(results)

Développement continu OpenQASM dans le QDK

La prise en charge de OpenQASM dans le QDK est en cours.

Pour obtenir la liste des fonctionnalités OpenQASM en cours de développement dans le QDK, consultez Limitations et problèmes connus sur le wiki QDK GitHub.

  • Last updated on