Köra kvantberäkningsjobb med hybridberäkning med anpassningsbar target profil
Hybridberäkning kombinerar klassiska processer och kvantberäkningsprocesser för att lösa komplexa problem.
Inom hybridberäkning styr den klassiska koden körningen av kvantåtgärder baserat på mätningar i mitten av kretsen medan de fysiska kvantbitarna förblir aktiva. Du kan använda vanliga programmeringstekniker, till exempel kapslade villkor, loopar och funktionsanrop, i ett enda kvantprogram för att köra komplexa problem, vilket minskar antalet skott som behövs. Med tekniker för återanvändning av kvantbitar kan större program köras på datorer med ett mindre antal kvantbitar.
Den här artikeln beskriver hur du skickar hybridjobb till Azure Quantum med hjälp av profilen QIR Adaptive RItarget . Den adaptiva RI-profilen target har stöd för mellankretsmätningar, mätbaserat kontrollflöde, kvantbitsåterställning och klassisk heltalsberäkning.
Förutsättningar
- Ett Azure-konto med en aktiv prenumeration. Om du inte har något Azure-konto registrerar du dig kostnadsfritt och registrerar dig för en betala per användning-prenumeration.
- En Azure Quantum-arbetsyta. Mer information finns i Skapa en Azure Quantum-arbetsyta.
- Om du vill skicka Q# fristående program behöver du följande krav:
- Visual Studio Code med Azure-tillägget Quantum Development Kit installerat.
- Den senaste versionen av Azure-tilläggetQuantum Development Kit.
- Om du vill skicka Python + Q# program behöver du följande förutsättningar:
En Python-miljö med Python och Pip installerade.
Azure Quantum
azure-quantumochqsharppaket.pip install --upgrade azure-quantum qsharp
Stödd targets
Om du vill köra kvantberäkningsjobb för hybrid måste du välja en kvantprovider som stöder den anpassningsbara RI-profilentarget.
För närvarande stöds anpassningsbar target profil i Azure Quantum på Quantinuumtargets.
Skicka anpassningsbara RI-jobb
Om du vill skicka hybrid-kvantberäkningsjobb måste du konfigurera profilen target som QIR Adaptive RI, där RI står för "qubit Reset och Integer computations".
Profilen QIR Adaptive RItarget har stöd för mellankretsmätningar, mätbaserat kontrollflöde, kvantbitsåterställning och klassisk heltalsberäkning.
Du kan skicka hybrid kvantjobb till Azure Quantum som Q# fristående program eller Python + Q# program. Information om hur du konfigurerar profilen target för hybrid kvantjobb finns i följande avsnitt.
Följ dessa steg för att konfigurera profilen target för hybridjobb i Visual Studio Code:
- Öppna ett Q# program i Visual Studio Code.
- Välj Visa –> Kommandopalett och skriv Q#: Ange Azure Quantum QIR-profilentarget. Tryck på Retur.
- Välj QIR Adaptive RI.
När du har angett QIR Adaptive RI som target profil kan du skicka ditt Q# program som ett hybrid-kvantjobb till Quantinuum.
- Välj Visa –> Kommandopalett och skriv Q#: Anslut till en Azure Quantum-arbetsyta. Tryck på Retur.
- Välj Azure-konto och följ anvisningarna för att ansluta till önskad katalog, prenumeration och arbetsyta.
- När du är ansluten expanderar du Quantum Workspaces i explorer-fönstret.
- Expandera din arbetsyta och expandera Quantinuum-providern .
- Välj valfri quantinuum tillgänglig target, till exempel quantinuum.sim.h1-1e.
- Välj uppspelningsikonen till höger om target namnet för att börja skicka det aktuella Q# programmet.
- Lägg till ett namn för att identifiera jobbet och antalet bilder.
- Tryck på Retur för att skicka jobbet. Jobbstatusen visas längst ned på skärmen.
- Expandera Jobb och hovra över jobbet, vilket visar tid och status för ditt jobb.
Funktioner som stöds
I följande tabell visas de funktioner som stöds för hybridberäkning av kvantberäkning med Quantinuum i Azure Quantum.
| Funktion som stöds | Kommentar |
|---|---|
| Dynamics-värden | Bools och heltal vars värde är beroende av ett mätresultat |
| Loopar | Endast klassiskt avgränsade loopar |
| Godtyckligt kontrollflöde | Användning av if/else-förgrening |
| Mätning av mellankretsar | Använder klassiska registerresurser |
| Återanvändning av qubit | Stöds |
| Klassisk beräkning i realtid | 64-bitars signerad heltalsaritmetik Använder klassiska registerresurser |
QDK ger targetspecifik feedback när Q# språkfunktioner inte stöds för den valda target. Om ditt Q# program innehåller funktioner som inte stöds när du kör hybrid-kvantjobb får du ett felmeddelande vid designtillfället. Mer information finns på QIR wiki-sidan.
Kommentar
Du måste välja lämplig QIR Adaptive RItarget profil för att få lämplig feedback när du använder Q# funktioner som target inte stöds.
Om du vill se vilka funktioner som stöds kopierar du följande kod till en Q# fil och lägger till efterföljande kodfragment.
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
}
Quantinuum stöder dynamiska bools och heltal, vilket innebär bools och heltal som är beroende av mätresultat. Observera att är r0 en Result typ som kan användas för att generera dynamiska bool- och heltalsvärden.
let dynamicBool = r0 != Zero;
let dynamicBool = ResultAsBool(r0);
let dynamicInt = dynamicBool ? 0 | 1;
Quantinuum stöder dynamiska bools och heltal, men det stöder inte dynamiska värden för andra datatyper, till exempel dubbel. Kopiera följande kod för att se feedback om begränsningarna för dynamiska värden.
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
Även om dynamiska värden inte stöds för vissa datatyper kan dessa datatyper fortfarande användas med statiska värden.
let staticRoot = Sqrt(4.0);
let staticBigInt = IntAsBigInt(2);
Inte ens dynamiska värden som stöds kan användas i vissa situationer. Till exempel stöder Quantinuum inte dynamiska matriser, det vill säga matriser vars storlek är beroende av ett mätresultat. Quantinuum stöder inte heller dynamiskt avgränsade loopar. Kopiera följande kod för att se begränsningarna för dynamiska värden.
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);
}
Quantinuum stöder kontrollflöde, inklusive if/else förgrening, med både statiska och dynamiska villkor. Förgrening av dynamiska villkor kallas även förgrening baserat på mätresultat.
let dynamicInt = r0 == Zero ? 0 | 1;
if dynamicInt > 0 {
X(q1);
}
let staticInt = 1;
if staticInt > 5 {
Y(q1);
} else {
Z(q1);
}
Quantinuum stöder loopar med klassiska villkor och inklusive if uttryck.
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)
}
}
Quantinuum stöder mätning i mitten av kretsen, dvs. förgrening baserat på mätresultat.
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);
}
Beräkna kostnaden för ett kvantberäkningsjobb för hybrid
Du kan beräkna kostnaden för att köra ett hybrid-kvantberäkningsjobb på Quantinuum-maskinvaran genom att först köra det på en emulator.
Efter en lyckad körning på emulatorn:
- På din Azure Quantum-arbetsyta väljer du Jobbhantering.
- Välj det jobb som du skickade.
- I popup-fönstret Jobbinformation väljer du Kostnadsuppskattning för att visa hur många eHQCs (Quantinuum-emulatorkrediter) som användes. Det här talet översätts direkt till antalet HQCs (Kvantkrediter för Quantinuum) som behövs för att köra jobbet på Quantinuum-maskinvara.
Kommentar
Quantinuum avregistrerar hela kretsen och beräknar kostnaden för alla kodsökvägar, oavsett om de körs villkorligt eller inte.
Hybridexempel för kvantberäkning
Följande exempel finns i Q# lagringsplatsen för kodexempel. De demonstrerar den aktuella funktionsuppsättningen för hybridberäkning av kvantberäkning.
Upprepningskod med tre qubit
Det här exemplet visar hur du skapar en upprepningskod med tre kvantbitar som kan användas för att identifiera och korrigera bitvändningsfel.
Den använder integrerade hybridberäkningsfunktioner för att räkna antalet gånger felkorrigeringen utfördes medan tillståndet för ett logiskt kvantbitsregister är sammanhängande.
Du hittar kodexemplet här.
Iterativ fasuppskattning
Det här exempelprogrammet visar en iterativ fasuppskattning inom Q#. Den använder iterativ fasuppskattning för att beräkna en inre produkt mellan två 2-dimensionella vektorer kodade på en target qubit och en ancilla qubit. Ytterligare en kontrollkvabit initieras också, vilket är den enda kvantbit som används för mätning.
Kretsen börjar med att koda vektorparet på qubiten target och ancilla qubiten. Den tillämpar sedan en Oracle-operator på hela registret, som styrs av kontrollkvabiten, som har konfigurerats i tillståndet $\ket +$ . Den kontrollerade Oracle-operatorn genererar en fas i tillståndet $\ket 1$ för kontrollkvabiten. Detta kan sedan läsas genom att tillämpa en H-grind på kontrollkvabiten för att göra fasen observerbar vid mätning.
Du hittar kodexemplet här.
Kommentar
Den här exempelkoden skrevs av medlemmar i KPMG Quantum-teamet i Australien och omfattas av en MIT-licens. Den visar utökade funktioner QIR Adaptive RItargets i och använder avgränsade loopar, klassiska funktionsanrop vid körning, kapslade villkorsstyrda if-instruktioner, mätningar av mellankretsar och återanvändning av kvantbitar.