Entwickeln Sie OpenQASM-Programme im Microsoft Quantum Development Kit

Der Microsoft Quantum Development Kit (QDK) bietet verschiedene Entwicklungsumgebungen für OpenQASM Programme mit Azure Quantum Integration. In diesem Artikel erfahren Sie, wie Sie Code entwickeln und ausführen OpenQASM in:

  • Die Erweiterung QDK in Visual Studio Code (VS Code)
  • Das QDK Python-Paket in Jupyter Notebook.

Developer-Tools wie CodeLends, IntelliSense, Code-Vervollständigung und Haltepunkt-Debugging sind nur in der Erweiterung VS Code verfügbar. Weitere Features sind nur im Python-Paket verfügbar. Beispielsweise können Sie Q# und OpenQASM-Aufrufe als Python-Objekte übergeben undOpenQASM-Programme, die Eingaben entgegennehmen, in QIR kompilieren.

Voraussetzungen

  • Installieren der neuesten Version von VS Code

  • Um direkt mit OpenQASM Dateien zu arbeiten, installieren Sie die neueste Version der QDK Erweiterung in VS Code.

  • Um mit OpenQASM in Python und Jupyter Notebook zu arbeiten, installieren Sie die neueste Version der Erweiterung Python und die erweiterung Jupyter in VS Code.

  • Installieren Sie die neueste Version des qdk Python-Pakets mit dem Extra jupyter:

    pip install --upgrade "qdk[jupyter]"

Arbeiten Sie mit OpenQASM in VS Code mit der QDK-Erweiterung

Um OpenQASM-Code in VS Code zu schreiben, öffnen Sie ein Q#-Projekt und erstellen Sie eine OpenQASM-Datei mit der Erweiterung .qasm. Das QDK erkennt die .qasm Datei automatisch als OpenQASM, und die QDK Features sind für OpenQASM verfügbar, während Sie Ihren Code schreiben.

Die folgenden QDK Features sind für OpenQASM Programme verfügbar in VS Code:

  • Codevervollständigung
  • Code-Lenses (Run, Histogram, Estimate, Debug und Circuit)
  • Syntaxmarkierung und grundlegende Syntaxfunktionen, z. B. Klammerabgleich
  • Fehlerüberprüfung in OpenQASM Quelldateien
  • Breakpoint-Debugging und Skriptausführung für OpenQASM Quelldateien
  • Fehlersuche mit live Generieren von Schaltungen
  • Integration mit Azure Quantum für die Quantenauftragsübermittlung

Um Ihr OpenQASM-Programm von VS Code zur Ausführung zu bringen, können Sie entweder den lokalen Simulator von QDK verwenden oder den Code als Auftrag an Azure Quantum übermitteln.

Ausführen des Codes im QDK lokalen Simulator

Um Ihren OpenQASM Code im lokalen Sparse-Quantum-Simulator in VS Code auszuführen, öffnen Sie eine .qasm-Datei und wählen Sie dann den Befehl Ausführen aus der CodeLens am Anfang der Datei aus. Die Ausgabe Ihres Programms wird im VS Code-Terminal angezeigt.

Hinweis

Das QDK versucht automatisch, ein QIR-targetProfil festzulegen, das Ihr Programm unterstützt. Wenn das QIR-Profil target Vorgänge in Ihrem Programm nicht unterstützt, erhalten Sie Compilerfehler, wenn Sie Ihren OpenQASM Code ausführen. Weitere Informationen zu target Profilen finden Sie unter Differente Typen von target Profilen in Azure Quantum.

Integrierte Beispielprogramme

Das QDK verfügt über mehrere integrierte Quantenalgorithmusbeispiele für OpenQASM. Um die Beispielalgorithmen auszuprobieren, geben Sie sample in eine leere .qasm Datei ein. Es wird eine Abschlussliste angezeigt, die die Beispielalgorithmen enthält. Wählen Sie ein Beispiel aus, und führen Sie dann den generierten Code aus.

Lokal debuggen in VS Code

Dies QDK umfasst einen Debugger für OpenQASM. Der Debugger unterstützt das Debuggen im Haltepunktstil und kann den Programmzustand rendern.

Um den Debugger zu starten, wählen Sie den Befehl "Debuggen " aus der Codelinse aus.

Im Debugmodus können Sie Haltepunkte in Ihrem Code festlegen, um Sie beim Debuggen zu unterstützen. Der Status Des Programms wird im Bereich "AUSFÜHREN UND DEBUGGEN " angezeigt. Sie können z. B. ihre lokalen Variablenzustände und Qubitzustände anzeigen.

Führen Sie Ihren Code auf Azure Quantum aus

Zum Ausführen von OpenQASM Programmen auf Azure Quantumtargets müssen Sie über einen Azure Quantum Arbeitsbereich verfügen. Informationen zum Erstellen eines Azure Quantum Arbeitsbereichs finden Sie unter Erstellen eines Azure Quantum Arbeitsbereichs.

Um OpenQASM Aufträge von Azure Quantum an VS Code zu senden, müssen Sie sich mit Ihrem Azure Quantum-Arbeitsbereich verbinden. Informationen zum Herstellen einer Verbindung mit Ihrem Arbeitsbereich über VS Code finden Sie unter Herstellen einer Verbindung mit einer Verbindungszeichenfolge.

Um einen OpenQASM Auftrag von Azure Quantum an VS Code zu übermitteln, führen Sie die folgenden Schritte aus:

  1. Öffnen Sie die qasm-Datei, die Ihr Programm in VS Code enthält.
  2. Wählen Sie das Microsoft Quantum-Symbol aus, um das Microsoft Quantum-Panel zu öffnen.
  3. Erweitern Sie das Dropdown-Menü QUANTUM WORKSPACES und wählen Sie Ihren Arbeitsbereich aus.
  4. Öffnen Sie die Dropdownliste Anbieter und wählen Sie einen Anbieter aus. Wählen Sie dann die target, auf der Sie Ihren Job ausführen möchten. Übermitteln Sie z. B. Ihren Auftrag an den rigetti.svm.simtarget Back-End-Simulator von Rigetti, um Ihr Programm auszuführen. Weitere Informationen zu Anbieter und target Verfügbarkeit finden Sie unter Hinzufügen oder Entfernen eines Anbieters in einem vorhandenen Arbeitsbereich.
  5. Wählen Sie das Wiedergabesymbol neben dem target Namen aus.
  6. Um den Auftrag zu übermitteln, geben Sie Werte für die Aufforderung " Auftragsname " und die Aufforderung "Anzahl der Aufnahmen" ein.

Um die Zeiten und den Status eines Auftrags anzuzeigen, erweitern Sie die Dropdownliste "Aufträge ", und zeigen Sie auf den Namen des Auftrags. Um die Auftragsergebnisse herunterzuladen, wählen Sie das Histogramm oder textsymbole neben dem Auftragsnamen aus.

Arbeiten mit OpenQASM in Python und Jupyter Notebook

Mit dem QDK Python-Paket können Sie Code direkt ausführen OpenQASM und Schaltkreise als Vorgänge an Q#-Programme übergebenOpenQASM. Schreiben Sie Ihren OpenQASM Code als Python Zeichenfolge, und verwenden Sie dann diese Zeichenfolge, um den code OpenQASM in der Python Umgebung auszuführen, zu importieren oder zu kompilieren.

Führen Sie OpenQASM direkt in Python

Um OpenQASM Code direkt auszuführen, verwenden Sie die run Funktion aus dem qdk.openqasm Modul. Zum Beispiel: Der folgende Code führt 10 Durchläufe auf dem lokalen Simulator eines einfachen OpenQASM-Programms mit Rauschen aus.

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)

Aufrufen eines OpenQASM Programms in Q#

Sie können die Funktion import_openqasm verwenden, um ein OpenQASM-Programm als Python-Objekt zu speichern und dieses Objekt später im Python Code aufzurufen. In der folgenden Zelle wird beispielsweise ein OpenQASM-Schaltkreis in einem Python-Objekt gespeichert, das bell heißt:

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

Wenn bell Teil Ihrer Umgebung ist, können Sie es direkt aus einer Q#-Zelle ausführen.

%%qsharp

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

Sie können die QDK Paketfunktionalität auch mit bell verwenden, z. B. für störanfällige Simulationen, Schaltkreisvisualisierung und Codegenerierung.

Parametrisierte OpenQASM Programme

In der folgenden Zelle wird ein OpenQASM-Schaltkreis erstellt, der einen Winkel theta als Eingabe verwendet und dann den Schaltkreis als Python Funktion aufruft:

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)

Übergeben eines OpenQASM Programms an Q#

Mit dem QDK Python-Paket können Sie ein OpenQASM Programm direkt an ein Q#-Programm übergeben. Mit dem folgenden Code wird beispielsweise ein OpenQASM Programm mit dem Namen Entangle erstellt und dann als Operation Entangle in einem Q#-Programm verwendet.

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) }")

Wenn Sie Q# importieren und OpenQASM Programme in einer Python Umgebung mit qsharp.eval und import_openqasm importieren, werden diese Programme zu Python Objekten, die Sie in Ihrem Python Code aufrufen können. Der folgende Code erstellt z. B. ein Q#-Programm namens TestAntiCorrelation und übergibt das EntangleOpenQASM Programm an 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)

Kompilieren von OpenQASM Programmen in QIR

Mit der Funktion OpenQASM können Sie compile Code in Quantum Intermediate Representation (QIR) kompilieren.

Zum Beispiel kompiliert die folgende Zelle OpenQASM Code für einen parametrisierten Schaltkreis in 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)

Hinweis

Um Programme zu kompilierenOpenQASM, die Eingabevariablen in QIR aufnehmen, müssen Sie das QDK Python-Paket verwenden. Sie können parametrisierte OpenQASM Programme nicht mithilfe der QDK Erweiterung in VS CodeQIR kompilieren.

Übermitteln von OpenQASM Programmen an Azure Quantum

Um ein OpenQASM-Programm zur Ausführung auf einem Azure Quantumtarget einzureichen, kompilieren Sie den OpenQASM-Code in QIR und reichen Sie dann das QIR zur Ausführung auf Azure Quantum ein.

Kompilieren Sie beispielsweise einen einfachen Verschränkungsschaltkreis in 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)

Um einen QIR-Auftrag auf Azure Quantum auszuführen, verbinden Sie sich mit Ihrem Quantenarbeitsbereich und übermitteln Sie den Auftrag an einen der verfügbaren targets in Ihrem Workspace. Übermitteln Sie z. B. das Veranglement QIR, um auf dem IonQ-Back-End-Simulator ausgeführt zu werden.

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)

Laufende OpenQASM Entwicklung im QDK

Die Unterstützung für OpenQASM in der QDK läuft weiterhin.

Eine Liste der Funktionen OpenQASM, die im QDK entwickelt werden, finden Sie unter Bekannte Einschränkungen und Probleme im QDK GitHub-Repository-Wiki.

  • Last updated on