Vývoj programů OpenQASM v Microsoft Quantum Development Kit

Microsoft Quantum Development Kit (QDK) poskytuje různá vývojová prostředí pro programy OpenQASM s integrací Azure Quantum. V tomto článku se dozvíte, jak vyvíjet a spouštět kód OpenQASM v:

  • Rozšíření QDK v Visual Studio Code (VS Code)
  • Balíček QDK Python v Jupyter Notebook.

Vývojářské nástroje jako CodeLends, IntelliSense, dokončování kódu a ladění pomocí zarážek jsou k dispozici pouze v rozšíření VS Code. Další funkce jsou k dispozici pouze v balíčku Python. Můžete například předávat Q# a OpenQASM volatelné prvky jako objekty Pythonu a kompilovat OpenQASM programy, které přijímají vstupy, do QIR.

Požadavky

  • Instalace nejnovější verze VS Code

  • Pokud chcete pracovat přímo se OpenQASM soubory, nainstalujte nejnovější verzi rozšíření QDK do VS Code.

  • Pokud chcete pracovat s OpenQASM v Pythonu a Jupyter Notebooku, nainstalujte nejnovější verzi rozšíření Python a rozšíření Jupyter v VS Code.

  • Nainstalujte nejnovější verzi qdk balíčku Python navícjupyter:

    pip install --upgrade "qdk[jupyter]"

Práce s OpenQASM v VS Code s použitím rozšíření QDK

Pokud chcete napsat OpenQASM kód v VS Code, otevřete projekt Q# a vytvořte soubor OpenQASM s příponou .qasm. Automaticky QDK rozpozná .qasm soubor jako OpenQASM, a funkce QDK pro OpenQASM jsou k dispozici při psaní kódu.

Následující funkce jsou k dispozici pro programy v QDKOpenQASM:

  • Dokončování kódu
  • Objektivy kódu (Spustit, Histogram, Odhad, Ladit a Circuit)
  • Zvýrazňování syntaxe a základní funkce syntaxe, například párování závorek
  • Kontrola chyb ve zdrojových souborech OpenQASM
  • Ladění bodů přerušení a spouštění skriptů pro OpenQASM zdrojové soubory
  • Ladění s využitím generování živého obvodu
  • Integrace s Azure Quantum pro odesílání kvantových úloh

Ke spuštění programu OpenQASM z VS Code můžete použít místní simulátor QDK nebo můžete kód odeslat jako úlohu do Azure Quantum.

Spuštění kódu v místním simulátoru QDK

Chcete-li spustit svůj kód OpenQASM v lokálním simulátoru řídkých kvantových stavů v VS Code, otevřete soubor .qasm a potom v náhledu CodeLens na začátku souboru vyberte příkaz Spustit. Výstup z programu se zobrazí v VS Code terminálu.

Poznámka:

QDK se automaticky pokusí nastavit profil QIR target, který podporuje váš program. Pokud profil QIR target nepodporuje operace v programu, při spuštění OpenQASM kódu se zobrazí chyby kompilátoru. Další informace o profilech target naleznete v tématu Různé typy profilů target v Azure Quantum.

Integrované ukázkové programy

Součástí QDK je několik předdefinovaných ukázek kvantových algoritmů pro OpenQASM. Pokud chcete vyzkoušet vzorové algoritmy, zadejte sample do prázdného souboru .qasm. Zobrazí se seznam dokončení obsahující ukázkové algoritmy. Zvolte ukázku a spusťte vygenerovaný kód.

Ladit lokálně v VS Code

QDK zahrnuje ladicí program pro OpenQASM. Ladicí program podporuje ladění s využitím zarážek a může zobrazit stav programu.

Pokud chcete spustit ladicí program, vyberte příkaz Ladit z CodeLens.

V režimu ladění můžete v kódu nastavit zarážky, které vám pomůžou ladit. Stav vašeho programu se zobrazuje v podokně SPUSTIT A LADIT. Můžete například zobrazit stavy místních proměnných a stavy qubitu.

Spusťte svůj kód na Azure Quantum

Pro spuštění programů OpenQASM v prostředí Azure Quantumtargets potřebujete pracovní prostředí Azure Quantum. Pokud chcete vytvořit Azure Quantum pracovní prostor, přečtěte si téma Vytvoření Azure Quantum pracovního prostoru.

Chcete-li odesílat úlohy OpenQASM do Azure Quantum z VS Code, musíte se připojit ke svému pracovnímu prostoru Azure Quantum. Pokud se chcete připojit ke svému pracovnímu prostoru z VS Code, viz Připojení pomocí připojovacího řetězce.

Chcete-li odeslat OpenQASM úlohu do Azure Quantum z VS Code, postupujte takto:

  1. Otevřete soubor qasm s vaším programem v VS Code.
  2. Výběrem ikony Microsoft Quantum otevřete panel Microsoft Quantum.
  3. Rozbalte rozevírací seznam QUANTUM WORKSPACES a vyberte svůj pracovní prostor.
  4. Rozbalte rozevírací seznam Poskytovatelé a zvolte poskytovatele a pak zvolte target , na které chcete úlohu spustit. Například odešlete svou úlohu do rigetti.svm.simtarget, abyste spustili svůj program v backendovém simulátoru Rigetti. Další informace o poskytovateli a target dostupnosti najdete v tématu Přidání nebo odebrání poskytovatele v existujícím pracovním prostoru.
  5. Vyberte ikonu přehrávání vedle target názvu.
  6. Pokud chcete úlohu odeslat, zadejte hodnoty pro výzvu název úlohy a výzvu Počet snímků .

Pokud chcete zobrazit časy a stav úlohy, rozbalte rozevírací seznam Úlohy a najeďte myší na název úlohy. Pokud chcete stáhnout výsledky úlohy, vyberte histogram nebo textové ikony vedle názvu úlohy.

Práce s OpenQASM v rámci Pythonu a Jupyter Notebooku

S balíčkem QDK Python můžete kód spouštět OpenQASM přímo a předávat OpenQASM okruhy jako operace do programů q#. Napište kód OpenQASM jako řetězec Python a pak tento řetězec použijte ke spuštění, importu nebo kompilaci kódu OpenQASM v prostředí Python.

Spusťte OpenQASM přímo v Python

Pokud chcete OpenQASM kód spustit přímo, použijte funkci run z modulu qdk.openqasm. Například následující kód spustí 10 snímků na místním simulátoru jednoduchého OpenQASM programu s šumem:

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)

OpenQASM Volání programu v Q#

Funkci import_openqasm můžete použít k uložení programu OpenQASM jako objektu Python a následnému volání objektu později v kódu Python. Následující buňka například ukládá okruh OpenQASM v objektu Python s názvem 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")

Když je bell součástí vašeho prostředí, můžete ho spustit přímo z Q# buňky:

%%qsharp

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

Funkci balíčku můžete použít QDK také s bellhlučnou simulací, vykreslováním okruhu a generováním kódu.

Parametrizované OpenQASM programy

Následující buňka vytvoří obvod OpenQASM, který jako vstup vezme úhel theta a pak zavolá obvod jako funkci 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)

Předat program OpenQASM do Q#

S balíčkem QDK Python můžete program předat OpenQASM přímo do programu v jazyce Q#. Například následující kód vytvoří program nazvaný OpenQASMEntangle a poté použije Entangle jako operaci v programu 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) }")

Při importu jazyka Q# a importu programů OpenQASM v Python prostředí s qsharp.eval a import_openqasm se tyto programy stanou Python objekty, které můžete volat v kódu Python. Například následující kód vytvoří program jazyka Q# zvaný TestAntiCorrelation a program EntangleOpenQASM předá 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)

Kompilace OpenQASM programů do QIR

Kód OpenQASM můžete zkompilovat pomocí compile funkce do kvantové zprostředkující reprezentace (QIR).

Následující buňka například zkompiluje OpenQASM kód parametrizovaného okruhu 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)

Poznámka:

Chcete-li zkompilovat OpenQASM programy, které přebírají vstupní proměnné do QIR, musíte použít QDK balíček Python. Parametrizované OpenQASM programy nelze zkompilovat do QIR pomocí QDK rozšíření v VS Code souboru.

Odeslání OpenQASM programů do Azure Quantum

Chcete-li odeslat program OpenQASM pro spuštění na Azure Quantumtarget, zkompilujte kód OpenQASM do QIR a pak odešlete QIR ke spuštění na Azure Quantum.

Například zkompilujte jednoduchý obvod provázání 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)

Pokud chcete spustit úlohu QIR do Azure Quantum, připojte se ke svému kvantovému pracovnímu prostoru a odešlete úlohu do jednoho z dostupných targets ve vašem pracovním prostoru. Odešlete například propletení QIR ke spuštění v back-endovém simulátoru 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)

Průběžný OpenQASM vývoj v oblasti QDK

Podpora pro OpenQASM v rámci QDK stále probíhá.

Seznam funkcí OpenQASM, které jsou ve vývoji v QDK, najdete v tématu Známá omezení a problémy na wiki úložiště GitHub QDK.

  • Last updated on