Megosztás a következőn keresztül:

Hibrid kvantum-számítási feladatok futtatása adaptív target profillal

  • Cikk

A hibrid számítástechnika ötvözi a klasszikus és a kvantum-számítási folyamatokat az összetett problémák megoldásához.

A hibrid számítástechnikában a klasszikus kód vezérli a kvantumműveletek végrehajtását közép-áramköri mérések alapján, míg a fizikai qubitek aktívak maradnak. A gyakori programozási technikákat, például a beágyazott feltételes feltételeket, hurkokat és függvényhívásokat egyetlen kvantumprogramban használhatja összetett problémák futtatásához, csökkentve a szükséges lövések számát. A qubit újrafelhasználási technikákkal a nagyobb programok kisebb számú qubit használatával futtathatók a gépeken.

Ez a cikk bemutatja, hogyan küldhet be hibrid feladatokat az Azure Quantumba a QIR Adaptive RItarget profil használatával. Az Adaptív RI-profil target támogatja a közép-áramköri méréseket, a mérésalapú vezérlési folyamatot, a qubit alaphelyzetbe állítását és a klasszikus egész számszámítást.

Előfeltételek

  • Egy Azure-fiók, aktív előfizetéssel. Ha nem rendelkezik Azure-fiókkal, regisztráljon ingyenesen, és regisztráljon használatalapú fizetéses előfizetésre.
  • Egy Azure Quantum-munkaterület. További információ: Azure Quantum-munkaterület létrehozása.
  • Ha önálló programokat szeretne küldeni Q# , a következő előfeltételekre van szüksége:
  • Ha python + Q# programokat szeretne küldeni, a következő előfeltételekre van szüksége:

    • Python-környezet, amelyen telepítve van a Python és a Pip .

    • Az Azure Quantum azure-quantum és a qsharp csomagok.

      pip install --upgrade azure-quantum qsharp

Támogatott targets

Hibrid kvantum-számítási feladatok futtatásához ki kell választania egy olyan kvantumszolgáltatót, amely támogatja az Adaptív RI-profilttarget.

Az Azure Quantum adaptív target profilja jelenleg a Quantinuumban targetstámogatott.

Adaptív RI-feladatok beküldése

A hibrid kvantum-számítási feladatok beküldéséhez konfigurálnia kell a profilt , ahol QIR Adaptive RIa target RI a " és Integer computations"qubit Reset.

A QIR Adaptive RItarget profil támogatja a közép-áramköri méréseket, a mérésalapú vezérlési folyamatot, a qubit alaphelyzetbe állítását és a klasszikus egész számszámítást.

Hibrid kvantumfeladatokat küldhet az Azure Quantum-nak önálló programokként vagy Python+ Q# programokkéntQ#. A hibrid kvantumfeladatok profiljának konfigurálásához target tekintse meg a következő szakaszokat.

A Hibrid feladatok profiljának target a Visual Studio Code-ban való konfigurálásához kövesse az alábbi lépéseket:

  1. Nyisson meg egy Q# programot a Visual Studio Code-ban.
  2. Válassza a Nézet – Parancskatalógus lehetőséget, és írja beQ# az Azure Quantum QIR-profilttarget.> Nyomja le az Enter billentyűt.
  3. Válassza ki QIR Adaptive RI.

Miután beállította QIR Adaptive RI a profilt target , elküldheti a Q# programot hibrid kvantumfeladatként a Quantinuumnak.

  1. Válassza a Nézet –> Parancskatalógus lehetőséget, és írja be a következőtQ#: Csatlakozás Azure Quantum-munkaterülethez. Nyomja le az Enter billentyűt.
  2. Válassza ki az Azure-fiókot, és kövesse az utasításokat az előnyben részesített címtárhoz, előfizetéshez és munkaterülethez való csatlakozáshoz.
  3. Miután csatlakozott, az Explorer panelen bontsa ki a Kvantum-munkaterületeket.
  4. Bontsa ki a munkaterületet, és bontsa ki a Quantinuum-szolgáltatót .
  5. Válassza ki az elérhető targetQuantinuumot (például quantinuum.sim.h1-1e).
  6. Az aktuális Q# program elküldéséhez válassza a név jobb oldalán target található lejátszás ikont.
  7. Adjon hozzá egy nevet a feladat és a lövések számának azonosításához.
  8. Nyomja le az Enter billentyűt a feladat elküldéséhez. A feladat állapota a képernyő alján jelenik meg.
  9. Bontsa ki a Feladatok elemet, és vigye az egérmutatót a feladat fölé, amely megjeleníti a feladat idejét és állapotát.

Támogatott funkciók

Az alábbi táblázat a hibrid kvantum-számítástechnika és az Azure Quantum Quantinuum által támogatott funkcióit sorolja fel.

Támogatott funkció Jegyzetek
Dynamics-értékek Olyan logikai értékek és egész számok, amelyek értéke egy mérési eredménytől függ
Hurkok Csak klasszikusan határolt hurkok
Tetszőleges vezérlési folyamat Ha/más elágaztatás használata
Közép-áramkör mérése Klasszikus regisztrációs erőforrásokat használ
Qubit újrafelhasználása Támogatott
Valós idejű klasszikus számítás 64 bites aláírt egész számtani
Klasszikus regisztrációs erőforrásokat használ

A QDK -specifikus visszajelzést nyújt target, ha Q# a nyelvi funkciók nem támogatottak a kiválasztott target. Ha a Q# program nem támogatott funkciókat tartalmaz hibrid kvantumfeladatok futtatásakor, a tervezéskor hibaüzenet jelenik meg. További információ: QIR wikilap.

Feljegyzés

Ki kell választania a megfelelő QIR Adaptive RItarget profilt, hogy megfelelő visszajelzést kapjon a target nem támogatott funkciók használatakorQ#.

A támogatott funkciók működés közbeni megtekintéséhez másolja a következő kódot egy Q# fájlba, és adja hozzá a következő kódrészleteket.

namespace HybridIntegrated {
    open Microsoft.Quantum.Measurement;
    open Microsoft.Quantum.Math;
    open Microsoft.Quantum.Convert;

    @EntryPoint()
    operation Main() : Result {
        use (q0, q1) = (Qubit(), Qubit());
        H(q0);
        let r0 = MResetZ(q0);

        // Copy here the code snippets below to see the supported features 
        // in action.
        // Supported features include dynamic values, classically-bounded loops, 
        // arbitrary control flow, and mid-circuit measurement.

        r0
    }

}

A Quantinuum támogatja a dinamikus logikai értékeket és egész számokat, ami azt jelenti, hogy a mérési eredményektől függő logikai értékek és egész számok. Vegye figyelembe, hogy r0 egy Result olyan típus, amely dinamikus bool- és egész számértékek létrehozásához használható.

        let dynamicBool = r0 != Zero; 
        let dynamicBool = ResultAsBool(r0); 
        let dynamicInt = dynamicBool ? 0 | 1;

A Quantinuum támogatja a dinamikus logikai értékeket és az egész számokat, azonban más adattípusok, például a dupla értékek dinamikus értékeit nem támogatja. Másolja a következő kódot a dinamikus értékek korlátozásával kapcsolatos visszajelzések megtekintéséhez.

        let dynamicDouble = r0 == One ? 1. | 0.; // cannot use a dynamic double value
        let dynamicInt = r0 == One ? 1 | 0;
        let dynamicDouble = IntAsDouble(dynamicInt); // cannot use a dynamic double value
        let dynamicRoot = Sqrt(dynamicDouble); // cannot use a dynamic double value

Annak ellenére, hogy egyes adattípusok esetében a dinamikus értékek nem támogatottak, ezek az adattípusok továbbra is használhatók statikus értékekkel.

    let staticRoot = Sqrt(4.0);
    let staticBigInt = IntAsBigInt(2);

Bizonyos helyzetekben még a támogatott típus dinamikus értékei sem használhatók. A Quantinuum például nem támogatja a dinamikus tömböket, vagyis azokat a tömböket, amelyek mérete egy mérési eredménytől függ. A Quantinuum sem támogatja a dinamikusan kötött hurkokat. Másolja a következő kódot a dinamikus értékek korlátainak megtekintéséhez.

        let dynamicInt = r0 == Zero ? 2 | 4;
        let dynamicallySizedArray = [0, size = dynamicInt]; // cannot use a dynamically-sized array
        let staticallySizedArray = [0, size = 10];
        // Loops with a dynamic condition are not supported by Quantinuum.
        for _ in 0..dynamicInt {
            Rx(PI(), q1);
        }
        
        // Loops with a static condition are supported.
        let staticInt = 3;
        for _ in 0..staticInt {  
            Rx(PI(), q1);  
        }

A Quantinuum statikus és dinamikus feltételek használatával támogatja a vezérlési folyamatot, beleértve az if/else elágaztatást is. A dinamikus körülmények közötti elágaztatást a mérési eredmények alapján elágaztatásnak is nevezik.

        let dynamicInt = r0 == Zero ? 0 | 1; 
        if dynamicInt > 0 {
            X(q1);
        }
        let staticInt = 1;
        if staticInt > 5 {
            Y(q1);
        } else {
            Z(q1);
        }

A Quantinuum támogatja a klasszikus feltételekkel és kifejezésekkel if rendelkező hurkokat.

        for idx in 0..3 {
            if idx % 2 == 0 {
                Rx(ArcSin(1.), q0);
                Rz(IntAsDouble(idx) * PI(), q1)
            } else {
                Ry(ArcCos(-1.), q1);
                Rz(IntAsDouble(idx) * PI(), q1)
            }
        }

A Quantinuum támogatja a középköri mérést, vagyis a mérési eredmények alapján történő elágaztatást.

        if r0 == One {
            X(q1);
        }
        let r1 = MResetZ(q1);
        if r0 != r1 {
            let angle = PI() + PI() + PI()* Sin(PI()/2.0);
            Rxx(angle, q0, q1);
        } else {
            Rxx(PI() + PI() + 2.0 * PI() * Sin(PI()/2.0), q1, q0);
        }

Hibrid kvantum-számítási feladatok költségeinek becslése

A hibrid kvantum-számítási feladatok Quantinuum-hardveren való futtatásának költségeit úgy becsülheti meg, hogy először emulátoron futtatja.

Sikeres futtatás után az emulátoron:

  1. Az Azure Quantum-munkaterületen válassza a Feladatkezelés lehetőséget.
  2. Válassza ki a beküldött feladatot.
  3. A Feladat részletei előugró ablakban válassza a Költségbecslés lehetőséget, hogy megtekintse, hány eHQCs (Quantinuum emulator credits) volt használatban. Ez a szám közvetlenül a feladat Quantinuum hardveren való futtatásához szükséges HQC-k (Quantinuum kvantum-kreditek) számára fordítható le.

Költségbecslés

Feljegyzés

A Quantinuum feloldja a teljes kapcsolatcsoport regisztrációját, és kiszámítja az összes kódútvonal költségét, függetlenül attól, hogy feltételesen vannak-e végrehajtva.

Hibrid kvantum-számítástechnikai minták

A következő minták a kódminták adattárában Q#találhatók. Bemutatják a hibrid kvantum-számítástechnika jelenlegi funkciókészletét.

Három qubites ismétlési kód

Ez a minta bemutatja, hogyan hozhat létre három qubites ismétlési kódot , amely a bit tükrözési hibáinak észlelésére és javítására használható.

Integrált hibrid számítástechnikai funkciókat használ a hibajavítások számának megszámlálásához, miközben a logikai qubit-regiszter állapota koherens.

A kódmintát itt találja.

Iteratív fázisbecslés

Ez a mintaprogram egy iteratív fázisbecslést mutat be a .Q# Iteratív fázisbecsléssel számít ki egy belső terméket két, qubiten kódolt kétdimenziós vektor és egy target ancilla qubit között. Egy további vezérlő qubit is inicializálva van, amely az egyetlen, méréshez használt qubit.

A kapcsolatcsoport a qubit és target az ancilla qubit vektorpárjának kódolásával kezdődik. Ezután egy Oracle-operátort alkalmaz a teljes regiszterre, amelyet a vezérlő qubit szabályoz, amely $\ket +$ állapotban van beállítva. Az ellenőrzött Oracle-operátor létrehoz egy fázist a vezérlő qubit $\ket 1$ állapotában. Ez ezután olvasható egy H kapuval a vezérlő qubiten, hogy a fázis megfigyelhető legyen méréskor.

A kódmintát itt találja.

Feljegyzés

Ezt a mintakódot a KPMG Quantum csapatának tagjai írták Ausztráliában, és egy MIT-licenc alá tartoznak. Bemutatja a kötött hurkok, a klasszikus függvényhívások futási időben történő, beágyazott feltételes if utasítások, a középső kapcsolatcsoport-mérések és a qubit újrafelhasználásának kibővített képességeit QIR Adaptive RItargets .

Kapcsolódó tartalom