Hibrid kvantum-számítási feladatok futtatása adaptív target profillal
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:
- A Visual Studio Code telepítve van az Azure-bővítményselQuantum Development Kit.
- Az Azure-bővítmény Quantum Development Kitlegújabb verziója.
- 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 aqsharp
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:
- Nyisson meg egy Q# programot a Visual Studio Code-ban.
- Válassza a Nézet – Parancskatalógus lehetőséget, és írja beQ# az Azure Quantum QIR-profilttarget.> Nyomja le az Enter billentyűt.
- 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.
- 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.
- 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.
- Miután csatlakozott, az Explorer panelen bontsa ki a Kvantum-munkaterületeket.
- Bontsa ki a munkaterületet, és bontsa ki a Quantinuum-szolgáltatót .
- Válassza ki az elérhető targetQuantinuumot (például quantinuum.sim.h1-1e).
- Az aktuális Q# program elküldéséhez válassza a név jobb oldalán target található lejátszás ikont.
- Adjon hozzá egy nevet a feladat és a lövések számának azonosításához.
- Nyomja le az Enter billentyűt a feladat elküldéséhez. A feladat állapota a képernyő alján jelenik meg.
- 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.
import Microsoft.Quantum.Measurement.*;
import Microsoft.Quantum.Math.*;
import Microsoft.Quantum.Convert.*;
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:
- Az Azure Quantum-munkaterületen válassza a Feladatkezelés lehetőséget.
- Válassza ki a beküldött feladatot.
- 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.
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 .