Hybride kwantumcomputingtaken uitvoeren met adaptief target profiel
Hybride computing combineert klassieke en kwantumcomputingprocessen om complexe problemen op te lossen.
In hybride computing bepaalt de klassieke code de uitvoering van kwantumbewerkingen op basis van gemiddelde circuitmetingen terwijl de fysieke qubits actief blijven. U kunt veelgebruikte programmeertechnieken gebruiken, zoals geneste voorwaarden, lussen en functie-aanroepen, in één kwantumprogramma om complexe problemen uit te voeren, waardoor het aantal benodigde opnamen wordt verminderd. Bij hergebruik van qubittechnieken kunnen grotere programma's worden uitgevoerd op computers met een kleiner aantal qubits.
In dit artikel wordt uitgelegd hoe u hybride taken verzendt naar Azure Quantum met behulp van het QIR Adaptive RItarget profiel. Het adaptieve RI-profiel target biedt ondersteuning voor gemiddelde circuitmetingen, controlestroom op basis van metingen, qubitherstel en klassieke gehele getallen.
Vereisten
- Een Azure-account met een actief abonnement. Als u geen Azure-account hebt, registreert u zich gratis en registreert u zich voor een abonnement op basis van betalen per gebruik.
- Een Azure Quantum-werkruimte. Zie Een Azure Quantum-werkruimte maken voor meer informatie.
- Als u zelfstandige programma's wilt verzenden Q# , hebt u de volgende vereisten nodig:
- Visual Studio Code waarop de Azure-extensie Quantum Development Kit is geïnstalleerd.
- De nieuwste versie van de Azure-extensieQuantum Development Kit.
- Als u Python + Q# programma's wilt verzenden, hebt u de volgende vereisten nodig:
Een Python-omgeving waarop Python en Pip zijn geïnstalleerd.
De Azure Quantum
azure-quantumenqsharppakketten.pip install --upgrade azure-quantum qsharp
Ondersteund targets
Als u hybride kwantumcomputingtaken wilt uitvoeren, moet u een kwantumprovider selecteren die het adaptieve RI-profiel targetondersteunt.
Op dit moment wordt adaptief target profiel in Azure Quantum ondersteund op Quantinuumtargets.
Adaptieve RI-taken verzenden
Als u hybride kwantumcomputingtaken wilt verzenden, moet u het target profiel configureren als QIR Adaptive RI, waarbij RI staat voor 'qubit Reset en Integer computations'.
Het QIR Adaptive RItarget profiel biedt ondersteuning voor gemiddelde circuitmetingen, controlestroom op basis van metingen, qubitherstel en klassieke berekening van gehele getallen.
U kunt hybride kwantumtaken verzenden naar Azure Quantum als Q# zelfstandige programma's of Python + Q# programma's. Zie de volgende secties om het target profiel voor hybride kwantumtaken te configureren.
Volg deze stappen om het target profiel voor hybride taken in Visual Studio Code te configureren:
- Open een Q# programma in Visual Studio Code.
- Selecteer Weergave -> Opdrachtpalet en typQ#: Stel het Azure Quantum QIR-profiel target in. Druk op Enter.
- Selecteer QIR Adaptive RI.
Zodra u het target profiel hebt ingesteldQIR Adaptive RI, kunt u uw Q# programma als een hybride kwantumtaak verzenden naar Quantinuum.
- Selecteer Weergave -> Opdrachtpalet en typ Q#: Verbinding maken met een Azure Quantum-werkruimte. Druk op Enter.
- Selecteer het Azure-account en volg de aanwijzingen om verbinding te maken met uw voorkeursmap, abonnement en werkruimte.
- Zodra u verbinding hebt, vouwt u in het deelvenster Explorer kwantumwerkruimten uit.
- Vouw uw werkruimte uit en vouw de Quantinuum-provider uit.
- Selecteer een Quantinuum beschikbaar target, bijvoorbeeld quantinuum.sim.h1-1e.
- Selecteer het afspeelpictogram rechts van de target naam om het huidige Q# programma in te dienen.
- Voeg een naam toe om de taak en het aantal opnamen te identificeren.
- Druk op Enter om de taak in te dienen. De taakstatus wordt onder aan het scherm weergegeven.
- Vouw Taken uit en beweeg de muisaanwijzer over uw taak, waarin de tijden en status van uw taak worden weergegeven.
Ondersteunde functies
De volgende tabel bevat de ondersteunde functies voor hybride kwantumcomputing met Quantinuum in Azure Quantum.
| Ondersteunde functie | Opmerkingen |
|---|---|
| Dynamics-waarden | Bools en gehele getallen waarvan de waarde afhankelijk is van een meetresultaat |
| Lussen | Alleen klassieke gebonden lussen |
| Willekeurige controlestroom | Gebruik van if/else-vertakking |
| Middencircuitmeting | Maakt gebruik van klassieke registerbronnen |
| Qubit hergebruik | Ondersteund |
| Realtime klassieke berekening | 64-bits ondertekende gehele getallen Maakt gebruik van klassieke registerbronnen |
De QDK biedt target-specifieke feedback wanneer Q# taalfuncties niet worden ondersteund voor de geselecteerde target. Als uw Q# programma niet-ondersteunde functies bevat bij het uitvoeren van hybride kwantumtaken, ontvangt u een foutbericht tijdens het ontwerpen. Zie de QIR-wikipagina voor meer informatie.
Notitie
U moet het juiste QIR Adaptive RItarget profiel selecteren om relevante feedback te krijgen bij het gebruik van Q# functies die target niet worden ondersteund.
Als u de ondersteunde functies in actie wilt zien, kopieert u de volgende code naar een Q# bestand en voegt u de volgende codefragmenten toe.
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 ondersteunt dynamische bools en gehele getallen, wat betekent dat boolen en gehele getallen afhankelijk zijn van meetresultaten. Houd er rekening mee dat r0 dit een Result type is dat kan worden gebruikt om dynamische bool- en gehele getallen te genereren.
let dynamicBool = r0 != Zero;
let dynamicBool = ResultAsBool(r0);
let dynamicInt = dynamicBool ? 0 | 1;
Quantinuum ondersteunt dynamische bools en gehele getallen, maar biedt geen ondersteuning voor dynamische waarden voor andere gegevenstypen, zoals dubbel. Kopieer de volgende code om feedback te zien over de beperkingen van dynamische waarden.
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
Hoewel dynamische waarden niet worden ondersteund voor sommige gegevenstypen, kunnen deze gegevenstypen nog steeds worden gebruikt met statische waarden.
let staticRoot = Sqrt(4.0);
let staticBigInt = IntAsBigInt(2);
Zelfs dynamische waarden van ondersteunde typen kunnen niet worden gebruikt in bepaalde situaties. Quantinuum biedt bijvoorbeeld geen ondersteuning voor dynamische matrices, dat wil gezegd matrices waarvan de grootte afhankelijk is van een meetresultaat. Quantinuum biedt ook geen ondersteuning voor dynamisch gebonden lussen. Kopieer de volgende code om de beperkingen van dynamische waarden te bekijken.
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 ondersteunt controlestroom, inclusief if/else vertakkingen, met behulp van statische en dynamische voorwaarden. Vertakking op dynamische voorwaarden wordt ook wel vertakking genoemd op basis van meetresultaten.
let dynamicInt = r0 == Zero ? 0 | 1;
if dynamicInt > 0 {
X(q1);
}
let staticInt = 1;
if staticInt > 5 {
Y(q1);
} else {
Z(q1);
}
Quantinuum ondersteunt lussen met klassieke voorwaarden en met inbegrip van if expressies.
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 ondersteunt gemiddelde circuitmeting, dat wil gezegd vertakkingen op basis van meetresultaten.
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);
}
De kosten van een hybride kwantumcomputingtaak schatten
U kunt de kosten van het uitvoeren van een hybride kwantumcomputingtaak op Quantinuum-hardware schatten door deze eerst op een emulator uit te voeren.
Na een geslaagde uitvoering op de emulator:
- Selecteer taakbeheer in uw Azure Quantum-werkruimte.
- Selecteer de taak die u hebt verzonden.
- Selecteer in het pop-upvenster Taakdetails de optie Kostenraming om te bekijken hoeveel eHQC's (Quantinuum-emulatortegoed) zijn gebruikt. Dit getal wordt rechtstreeks omgezet in het aantal HQC's (Quantinuum-kwantumtegoeden) dat nodig is om de taak uit te voeren op Quantinuum-hardware.
Notitie
Quantinuum maakt de registratie van het hele circuit ongedaan en berekent de kosten voor alle codepaden, ongeacht of ze voorwaardelijk worden uitgevoerd of niet.
Voorbeelden van hybride kwantumcomputing
De volgende voorbeelden vindt u in Q# de opslagplaats met codevoorbeelden. Ze demonstreren de huidige functieset voor hybride kwantumcomputing.
Herhalingscode van drie qubits
In dit voorbeeld ziet u hoe u een herhalingscode van drie qubits maakt die kan worden gebruikt om bitspiegelfouten te detecteren en te corrigeren.
Het maakt gebruik van geïntegreerde hybride computingfuncties om het aantal keren te tellen dat foutcorrectie is uitgevoerd terwijl de status van een logisch qubitregister coherent is.
Hier vindt u het codevoorbeeld.
Schatting van iteratieve fase
Dit voorbeeldprogramma demonstreert een iteratieve faseraming binnen Q#. Er wordt gebruikgemaakt van iteratieve faseschatting om een binnenproduct te berekenen tussen twee twee twee dimensionale vectoren die zijn gecodeerd op een target qubit en een ancilla-qubit. Er wordt ook een extra controle-qubit geïnitialiseerd. Dit is de enige qubit die wordt gebruikt voor meting.
Het circuit begint met het coderen van het paar vectoren op de target qubit en de ancilla-qubit. Vervolgens wordt een Oracle-operator toegepast op het hele register, waarbij de controle-qubit wordt uitgeschakeld, die is ingesteld in de status $\ket +$. De gecontroleerde Oracle-operator genereert een fase op de status $\ket 1$ van de controle-qubit. Dit kan vervolgens worden gelezen door een H-poort toe te passen op de controle-qubit om de fase waarneembaar te maken bij het meten.
Hier vindt u het codevoorbeeld.
Notitie
Deze voorbeeldcode is geschreven door leden van het TEAM van MICROSOFT Quantum in Australië en valt onder een MIT-licentie. Het demonstreert uitgebreide mogelijkheden van QIR Adaptive RItargets en maakt gebruik van gebonden lussen, klassieke functie-aanroepen tijdens runtime, geneste voorwaardelijke if-instructies, gemiddelde circuitmetingen en qubit-hergebruik.