Opracowywanie programów OpenQASM w Microsoft Quantum Development Kit

Microsoft Quantum Development Kit (QDK) udostępnia różne środowiska programistyczne dla programów OpenQASM z integracją Azure Quantum. Z tego artykułu dowiesz się, jak opracowywać i uruchamiać OpenQASM kod w:

  • Rozszerzenie QDK w Visual Studio Code (VS Code)
  • QDK Pakiet Python w Jupyter Notebook.

Narzędzia deweloperskie, takie jak CodeLends, IntelliSense, autouzupełnianie kodu i debugowanie za pomocą punktów przerwania, są dostępne tylko w rozszerzeniu VS Code. Inne funkcje są dostępne tylko w pakiecie Python. Na przykład można przekazywać elementy wywoływalne Q# i OpenQASM jako obiekty języka Python oraz kompilować programy OpenQASM, które przyjmują dane wejściowe, do formatu QIR.

Wymagania wstępne

  • Zainstaluj najnowszą wersję programu VS Code

  • Aby pracować bezpośrednio z plikami OpenQASM , zainstaluj najnowszą wersję QDK rozszerzenia w programie VS Code.

  • Aby pracować z OpenQASM w Python i Jupyter Notebook, zainstaluj najnowszą wersję rozszerzenia Python oraz rozszerzenie Jupyter w VS Code.

  • Zainstaluj najnowszą wersję qdk pakietu Python z dodatkowymi jupyter elementami:

    pip install --upgrade "qdk[jupyter]"

Praca z OpenQASM w VS Code za pomocą rozszerzenia QDK

Aby napisać kod OpenQASM w VS Code, otwórz projekt języka Q# i utwórz plik OpenQASM z rozszerzeniem .qasm. Funkcja QDK automatycznie rozpoznaje plik .qasm jako OpenQASM, a funkcje QDK dla OpenQASM są dostępne w trakcie pisania kodu.

Następujące QDK funkcje są dostępne dla OpenQASM programów w VS Code:

  • Uzupełnianie kodu
  • Elementy wizualne kodu (Uruchom, Histogram, Oszacuj, Debuguj i Układ)
  • Wyróżnianie składni i podstawowe funkcje składni, takie jak dopasowywanie nawiasów klamrowych
  • Błąd podczas sprawdzania plików OpenQASM źródłowych
  • Debugowanie punktu przerwania i wykonywanie skryptu dla OpenQASM plików źródłowych
  • Debugowanie przy użyciu generowania obwodu na żywo
  • Integracja z Azure Quantum na potrzeby przesyłania zadań kwantowych

Aby uruchomić program OpenQASM z VS Code, możesz użyć lokalnego symulatora QDK lub przesłać kod jako zadanie do Azure Quantum.

Uruchamianie kodu w symulatorze QDK lokalnym

Aby uruchomić kod OpenQASM w lokalnym rzadkim symulatorze kwantowym w VS Code, otwórz plik .qasm, a następnie wybierz polecenie Uruchom z elementu CodeLens na początku pliku. Dane wyjściowe z programu są wyświetlane w terminalu VS Code .

Uwaga / Notatka

QDK automatycznie próbuje ustawić profil QIR target, który obsługuje dany program. Jeśli profil QIR target nie obsługuje operacji w programie, podczas uruchamiania kodu występują błędy kompilatora OpenQASM . Aby uzyskać więcej informacji na temat profilów target, zobacz Różne typy profilów target w Azure Quantum.

Wbudowane programy przykładowe

Zestaw QDK zawiera kilka wbudowanych przykładów algorytmów kwantowych dla OpenQASM. Aby wypróbować przykładowe algorytmy, wprowadź sample w pustym .qasm pliku. Zostanie wyświetlona lista uzupełniania zawierająca przykładowe algorytmy. Wybierz przykład, a następnie uruchom wygenerowany kod.

Debugowanie lokalnie w programie VS Code

Element QDK zawiera debuger dla programu OpenQASM. Debuger obsługuje debugowanie za pomocą punktów przerwania i może wizualizować stan programu.

Aby uruchomić debuger, wybierz polecenie Debuguj z CodeLens.

W trybie debugowania możesz ustawić punkty przerwania w kodzie, aby ułatwić debugowanie. Stan programu jest wyświetlany w okienku URUCHAMIANIE I DEBUGOWANIE . Możesz na przykład wyświetlić stany zmiennych lokalnych i stany kubitów.

Uruchom swój kod na Azure Quantum

Aby uruchamiać programy OpenQASM na Azure Quantumtargets, musisz mieć obszar roboczy Azure Quantum. Aby utworzyć Azure Quantum obszar roboczy, zobacz Tworzenie obszaru roboczegoAzure Quantum.

Aby przesłać zadania OpenQASM do Azure Quantum z VS Code, musisz połączyć się z obszarem roboczym Azure Quantum. Aby połączyć się z obszarem roboczym z poziomu VS Code, zobacz Jak nawiązać połączenie przy użyciu parametrów połączenia.

Aby przesłać zadanie OpenQASM do Azure Quantum z VS Code, wykonaj następujące kroki:

  1. Otwórz plik qasm, który zawiera twój program, w VS Code.
  2. Wybierz ikonę Microsoft Quantum, aby otworzyć panel Microsoft Quantum.
  3. Rozwiń listę rozwijaną QUANTUM WORKSPACES (OBSZARY ROBOCZE KWANTOWE ) i wybierz swój obszar roboczy.
  4. Rozwiń listę rozwijaną Dostawcy i wybierz dostawcę, a następnie wybierz target , na którym chcesz uruchomić zadanie. Na przykład prześlij swoje zadanie do rigetti.svm.simtarget, aby uruchomić program w symulatorze backendowym Rigettiego. Aby uzyskać więcej informacji na temat dostawcy i target dostępności, zobacz Dodawanie lub usuwanie dostawcy w istniejącym obszarze roboczym.
  5. Wybierz ikonę odtwarzania obok target nazwy.
  6. Aby wysłać zadanie, wprowadź wartości w polach Nazwa zadania i Liczba prób.

Aby wyświetlić czasy i stan zadania, rozwiń listę rozwijaną Zadania i umieść kursor nad nazwą zadania. Aby pobrać wyniki zadania, wybierz ikony histogramu lub tekstu obok nazwy zadania.

Praca z OpenQASM w środowisku Python oraz Jupyter Notebook.

QDK Pakiet Python umożliwia bezpośrednie uruchamianie OpenQASM kodu i przekazywanie OpenQASM obwodów jako operacji do programów języka Q#. Napisz kod OpenQASM jako ciąg Python, a następnie użyj tego ciągu, aby uruchomić, zaimportować lub skompilować kod OpenQASM w środowisku Python.

Uruchom OpenQASM bezpośrednio w Python

Aby uruchomić OpenQASM kod bezpośrednio, użyj run funkcji z modułu qdk.openqasm . Na przykład poniższy kod uruchamia 10 prób na lokalnym komputerowym symulatorze prostego OpenQASM programu z szumem.

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)

Wywołaj OpenQASM program w języku Q#

Możesz użyć funkcji import_openqasm do przechowywania programu OpenQASM jako obiektu Python, a następnie wywołać ten obiekt w dalszej części kodu Python. Na przykład następująca komórka przechowuje obwód OpenQASM w obiekcie Python o nazwie 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")

Gdy bell jest częścią środowiska, możesz uruchomić go bezpośrednio z komórki języka Q#:

%%qsharp

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

Możesz również użyć funkcjonalności pakietu QDK z funkcjonalnością bell, takimi jak hałaśliwe symulacje, renderowanie obwodu i generowanie kodu.

Programy sparametryzowane OpenQASM

Poniższa komórka tworzy obwód OpenQASM, który przyjmuje kąt theta jako wejście, a następnie wywołuje obwód jako funkcję 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)

OpenQASM Przekazywanie programu do języka Q#

Za pomocą pakietu QDK Python można bezpośrednio przekazać program OpenQASM do programu w języku Q#. Na przykład poniższy kod tworzy program OpenQASM o nazwie Entangle, a następnie używa Entangle jako operacji w programie 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) }")

Podczas importowania programów Q# i OpenQASM w środowisku Python za pomocą qsharp.eval i import_openqasm, te programy stają się obiektami języka Python, które można wywołać w kodzie Pythona. Na przykład, poniższy kod tworzy program Q# o nazwie TestAntiCorrelation i przekazuje program EntangleOpenQASM do 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)

Kompilowanie programów do QIR

Możesz skompilować kod OpenQASM do QuIR (Quantum Intermediate Representation) za pomocą funkcji compile.

Na przykład następująca komórka kompiluje OpenQASM kod dla sparametryzowanego obwodu do 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)

Uwaga / Notatka

Aby skompilować OpenQASM programy, które pobierają zmienne wejściowe do QIR, należy użyć QDK pakietu Python. Nie można skompilować sparametryzowanych OpenQASM programów do QIR przy użyciu rozszerzenia QDK w VS Code.

Przesyłanie OpenQASM programów do Azure Quantum

Aby przesłać program OpenQASM do uruchomienia na Azure Quantumtarget, skompiluj kod OpenQASM do QIR, a następnie prześlij QIR do uruchomienia na Azure Quantum.

Na przykład skompiluj prosty obwód generujący splątanie do 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)

Aby uruchomić zadanie QIR w usłudze Azure Quantum, połącz się z kwantowym obszarem roboczym i prześlij zadanie do jednego z dostępnych elementów targets w obszarze roboczym. Na przykład prześlij splątanie QIR do uruchomienia w symulatorze zaplecza 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)

Ciągły OpenQASM rozwój w QDK

Wsparcie dla OpenQASM w QDK jest w toku.

Aby uzyskać listę funkcji OpenQASM, które są w trakcie opracowywania w QDK, zobacz Znane ograniczenia i problemy na stronie wiki repozytorium QDK GitHub.

  • Last updated on