Vývoj s využitím Q# a Pythonu

  • Článek

Poznámka

Příklady v tomto tématu používají sadu Microsoft Quantum Development Kit (Classic QDK) a ještě nejsou kompatibilní s Azure Quantum Development Kit Preview (Moderní sada QDK). Další informace o moderní sadě QDK najdete na wikiwebu QSharp Na GitHubu.

Zjistěte, jak můžete spustit Q# program pomocí hostitelského programu v Pythonu nebo Jupyter Notebook, který vyvolá Q# kód a další procesy vrátí výsledky. Toto téma používá kvantové simulátory od Microsoftu Quantum Development Kit (QDK) k místnímu testování a spouštění kvantových programů.

Poznámka

Hostitelský program v Pythonu je normální program v Pythonu. K psaní programu Pythonu a volání operací Q# můžete použít libovolné prostředí Pythonu, včetně aplikací Jupyter Notebook založených na Pythonu. Hostitelský program v Pythonu může také importovat Q# operace z libovolných Q# souborů (.qs) umístěných ve stejné složce jako samotný kód Pythonu.

Požadavek

Nastavte prostředí Pythonu nebo nakonfigurujte stávající prostředí Pythonu tak, aby používalo microsoft QDK a Jupyter Notebooks, a to podle kroků v tématu Nastavení Quantum Development Kit.

Volba prostředí IDE

I když můžete s Pythonem v jakémkoli integrovaném vývojovém prostředí (IDE) psát Q# program v Pythonu a volat Q# operace, doporučujeme pro aplikace Q# + Python použít jupyter Notebooks nebo Visual Studio Code (VS Code).

Poznámkové bloky Jupyter

Jupyter Notebook je dokument, který obsahuje formátovaný text i kód a může běžet v prohlížeči a může spouštět Q# kód Pythonu v Azure Quantum. Poznámkové bloky je také možné vytvářet přímo na portálu Azure Quantum, který má qsharp předinstalovaný balíček Pythonu a nabízí funkce, jako jsou ukázkové poznámkové bloky a předem načtené informace o připojení.

Typy kvantových poznámkových bloků

Instalace sady QDK rozšíří jádro Pythonu v poznámkových blocích Juptyer Notebooks o qsharp balíček Pythonu a přidá také jádro IQ#, které umožňuje vytvářet samostatné Q# poznámkové bloky. Typ jádra vyberete při vytváření nového poznámkového bloku:

Snímek obrazovky s možnostmi pro jádra poznámkových bloků

Vyberte Python 3 (ipykernel) pro Python + Q# poznámkový blok a Q# pro Q# samostatný poznámkový blok.

  • Python + Q# poznámkový blok: Napište svůj program v Pythonu a importujte Q# operace a funkce ze samostatného Q# souboru. Můžete také použít příkaz magic %%qsharp k zápisu Q# kódu přímo do buňky poznámkového bloku.
  • Q# Samostatný poznámkový blok: Napište Q# kód přímo do poznámkového bloku a využijte příkazy magic specifické pro Azure Quantum nainstalované s QDK.

Tento článek popisuje procesy a postupy používané pouze s Pythonem a Q# poznámkovými bloky.

Další informace o používání poznámkových bloků Jupyter na portálu Azure Quantum najdete v tématu Začínáme s poznámkovým blokem Q# Azure Quantum.

Visual Studio Code (VS Code)

S rozšířením QDK pro VS Code získáte přístup k bohatším funkcím, jako jsou upozornění, zvýrazňování syntaxe, šablony projektů a další.

Pokud chcete použít VS Code:

VS Code také nabízí vlastní terminál, ze kterého můžete spouštět kód. Pokud používáte conda, nezapomeňte postupovat podle postupu popsaného v části instalace a inicializovat conda pro prostředí, které používá VS Code. Ve Windows bude VS Code používat PowerShell, pokud není nakonfigurovaný jinak. To vám umožní spouštět Q# programy v Pythonu přímo z integrovaného terminálu VS Code, ale s přístupem k Pythonu můžete použít libovolný terminál podle vašeho výběru. Nezapomeňte tam před spuštěním libovolného programu aktivovat své Q# prostředí pomocí conda activate qsharp-env.

Pokud chcete použít jiný editor, máte zatím všechny pokyny nastavené.

Poznámka

Všimněte si, že výstup programu se může zobrazit jinak, pokud kód spustíte v Jupyter Notebook místo na příkazovém řádku, protože toto rozhraní rozumí tomu, jak předávat diagnostiku založenou na HTML z jádra IQ# do jádra I.

Použití Q# s Pythonem

Abyste mohli začít, váš program v Pythonu musí importovat balíček Pythonu qsharp . Tento balíček poskytuje Q# interoperabilitu pro Python a jádro IQ# pro Jupyter, což umožňuje kompilovat a spouštět Q# operace z Pythonu a Q# poznámkových bloků Jupyter.

Po importu do programu balíček umožňujeQ#, qsharp aby se obory názvů zobrazovaly jako balíčky Pythonu, ze kterých můžete importovat Q# volatelné položky. Funkce a operace můžete používat Q# jako objekty Pythonu a metody pro tyto objekty můžete použít k určení target počítačů pro simulaci kvantových programů, odhadu kvantových prostředků atd. Váš hostitelský program v Pythonu nebo Jupyter Notebook může importovat Q# obory názvů ze všech Q# souborů (s příponou .qs) umístěných ve stejné složce.

  1. Vytvořte minimální Q#operaci tak, že vytvoříte soubor s názvem HostPython.qs a přidáte do něj následující kód:

    namespace HostPython {
    open Microsoft.Quantum.Intrinsic;

    operation SayHello(name : String) : Unit {
        Message($"Hello, {name}!");
    }
}

    Poznámka

    Atribut @EntryPoint() používaný pouze pro Q#aplikace -only nelze použít s hostitelskými programy. Pokud je v Q# souboru volaném hostitelem, vyvolá se chyba.

  2. Ve stejné složce jako HostPython.qsvytvořte následující program Python s názvem host.pynebo zadejte kód do buňky Juptyer Notebook. Tento program importuje operaci definovanou Q#v předchozím kroku a spustí ji ve výchozím simulátoru.simulate() pomocí metody :SayHello()

    import qsharp
from HostPython import SayHello

print(SayHello.simulate(name="quantum world"))

  3. Z terminálu s přístupem k prostředí Pythonu neboQ# prostředí vytvořenému během instalace přejděte do složky projektu a spusťte hostitelský program Pythonu nebo buňku Juptyer Notebook:

    python host.py

    Hello, quantum world!

  4. Vstupy do vaší Q# operace jsou reprezentovány argumenty klíčových slov Pythonu a výstupy se vrací zpět do hostitele Pythonu. Přidejte do programu například následující funkci PlusHostPython.qs a uložte ji:

    namespace HostPython {
    open Microsoft.Quantum.Intrinsic;

    operation SayHello(name : String) : Unit {
        Message($"Hello, {name}!");
    }

    function Plus(x : Int, y : Int) : Int {
        return x + y;
    }
}

    from HostPython import Plus

print(Plus.simulate(x=3, y=5))

    8

  5. Můžete také pracovat s qubity přidělenými v Q# programech a simulovat operaci z Pythonu. Přidejte do programu následující operaci CreateQuantumRNG, která vytvoří kvantový generátor náhodných bitů HostPython.qs :

    namespace HostPython {
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Measurement;

    operation SayHello(name : String) : Unit {
        Message($"Hello, {name}!");
    }

    function Plus(x : Int, y : Int) : Int {
        return x + y;
    }

    operation CreateQuantumRNG() : Result {
        use q = Qubit(); // Allocate a qubit.
        H(q); // Put the qubit to superposition. A Z-basis measurement now has a 50% chance of returning 0 or 1.
        return MResetZ(q); // Measure the qubit value.
    }
}

    from HostPython import CreateQuantumRNG

print(CreateQuantumRNG.simulate())

    Vzhledem k tomu, že CreateQuantumRNG operace vygeneruje náhodný výsledek, výsledek bude buď 0, nebo 1. Pokud program spouštíte opakovaně, měli by se oba výsledky zobrazovat přibližně stejně často.

Příkaz magic %%qsharp

Pokud operace spouštíte v Jupyter Notebook založeném na Pythonu (pomocí Pythonu 3 (ipykernel)), %%qsharp příkaz magic vám umožní napsat nový Q# kód v rámci stejného Jupyter Notebook jako kód Pythonu, abyste se vyhnuli nutnosti samostatného Q# a hostitelského programu.

  • Abyste povolili %%qsharp příkaz , musíte nejprve spustit import qsharp příkaz .
  • Příkaz %%qsharp je vymezený na buňku, ve které se zobrazí.
  • Kód Q# , který následuje za příkazem, musí dodržovat standardní Q# syntaxi kódování. Například komentáře jsou místo uvnitř buněk označeny pomocí //# .%%qsharp

První příklad v předchozí části by například Q# mohl být napsán a spuštěn s následujícími třemi buňkami:

import qsharp

%%qsharp

open Microsoft.Quantum.Intrinsic;

operation SayHello(name : String) : Unit {
    Message($"Hello, {name}!");
}

print(SayHello.simulate(name="quantum world"))

Všimněte si, že import qsharp před použitím %%qsharp příkazu musí být spuštěna ve vlastní buňce a print funkce musí být také spuštěna ve své vlastní buňce. Před %%qsharp příkazem nemůže být příkaz Pythonu v jeho buňce ani za ním.

Volání do Q# programu

%%qsharp Pomocí příkazu můžete zadat Q# kód přímo do buňky poznámkového bloku a zároveň využít externě definované Q# volatelné hodnoty.

Například ve stejné složce jako poznámkový blok a HostPython.qs soubor vytvořte následující Q# program s názvem OperationSamples.qs, který definuje tři různé operace:

namespace Microsoft.Quantum.Samples {
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Canon;

    operation PrepareBellPair(left : Qubit, right : Qubit) : Unit is Adj + Ctl {
        H(left);
        CNOT(left, right);
    }

    operation Teleport(msg : Qubit, target : Qubit) : Unit {
        use here = Qubit();

        PrepareBellPair(here, target);
        Adjoint PrepareBellPair(msg, here);

        if M(msg) == One { Z(target); }
        if M(here) == One { X(target); }
    }

    operation RunTeleportationExample() : Unit {
        use msg = Qubit();
        use target = Qubit();

        H(msg);
        Teleport(msg, target);
        H(target);

        if M(target) == Zero {
            Message("Teleported successfully!");
        }
    }
}

Operace je definovaná PrepareBellPair v OperationSamples.qs souboru, ale můžete ji volat z Q# operace PrepareAndMeasureBellPair(), kterou v poznámkovém bloku definujete pomocí %%qsharp příkazu magic (možná budete muset aktualizovat poznámkový blok a jádro, aby se nový Q# soubor rozpoznal):

%%qsharp
open Microsoft.Quantum.Samples;
open Microsoft.Quantum.Measurement;

operation PrepareAndMeasureBellPair() : (Result, Result) {
    use left = Qubit();
    use right = Qubit();

    PrepareBellPair(left, right);
    return (MResetZ(left), MResetZ(right));
}

PrepareAndMeasureBellPair.simulate()

Kompilace Q# z řetězců Pythonu

Kromě %%qsharp příkazu qsharp magic balíček poskytuje compile také funkci , která umožňuje kompilovat Q# kód z řetězců Pythonu:

sample_qrng = qsharp.compile("""
    open Microsoft.Quantum.Measurement; // namespace required for MResetZ operation
    operation CreateQuantumRNG() : Result {
        use q = Qubit();
        H(q);
        return MResetZ(q);
    }
""")
    
print(sample_qrng.simulate())

Balíčky a projekty

Kód Q# ve vašem pracovním prostoru může také záviset na jiných Q#balíčcích a projektech pomocí .csproj souborů projektu.

Tip

Pokud pro svůj pracovní prostor nemáte soubor projektu, qsharp balíček bude předpokládat některé rozumné výchozí hodnoty. Soubor projektu usnadňuje použití dalších balíčků, získání dokončování kódu a najetí dokumentace při úpravách Q# souborů a tak dále.

Poznámka

.csproj V současné době se soubory podporují jenom v místních prostředích, ne v poznámkových blocích hostovaných na portálu Azure Quantum.

Pokud chcete zjistit, jaké balíčky jsou aktuálně přidané do vašeho pracovního prostoru, použijte qsharp.packages objekt :

qsharp.packages

Nové balíčky můžete přidávat také dynamicky pomocí qsharp.packages.add objektu . Pokud chcete například přidat knihovnu QDK Chemistry:

qsharp.packages.add('Microsoft.Quantum.Chemistry')

qsharp.packages

Další kroky

Teď, když jste ve svém prostředí otestovali Quantum Development Kit , můžete postupovat podle tohoto kurzu a napsat a spustit svůj první kvantový program.

Další informace o spouštění Q# programů pomocí Pythonu najdete v následujících článcích: