Geïntegreerde hybride computing

Geïntegreerde hybride computing brengt de klassieke en kwantumprocessen samen, waardoor klassieke code de uitvoering van kwantumbewerkingen kan beheren op basis van gemiddelde circuitmetingen terwijl de fysieke qubits actief blijven. Met behulp van veelgebruikte programmeertechnieken, zoals geneste voorwaarden, lussen en functie-aanroepen, kan één kwantumprogramma complexe problemen uitvoeren, waardoor het aantal benodigde opnamen wordt verminderd. Met behulp van technieken voor hergebruik van qubits kunnen grotere programma's worden uitgevoerd op computers die een kleiner aantal qubits gebruiken.

Zie voor meer discussie:

• Granade & Weibe, "Using Random Walks for Iterative Phase Estimation".
• Lubinski, et al., "Geavanceerde hybride kwantum-klassieke berekening met realtime uitvoering"

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-extensie Quantum 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-quantum en qsharp pakketten.

    pip install --upgrade azure-quantum qsharp
    

Ondersteund targets

Op dit moment wordt het geïntegreerde hybride computingmodel in Azure Quantum ondersteund op Quantinuumtargets.

Geïntegreerde hybride taken verzenden

Wanneer u een geïntegreerde hybride taak indient, moet u het target profiel configureren als QIR Adaptive RI. Het QIR Adaptive RItarget profiel biedt ondersteuning voor gemiddelde circuitmetingen, controlestroom op basis van metingen, qubitherstel en klassieke berekening van gehele getallen.

U kunt geïntegreerde, hybride Q# zelfstandige programma's of Python + Q# programma's verzenden naar Azure Quantum. Volg de onderstaande instructies om het target profiel voor geïntegreerde hybride taken te configureren.

Q# in Visual Studio Code

Volg deze stappen om het target profiel te configureren voor geïntegreerde hybride taken in Visual Studio Code:

1. Open een Q# programma in Visual Studio Code.
2. Selecteer Weergave -> Opdrachtpalet en typQ#: Stel het Azure Quantum QIR-profiel target in. Druk op Enter.
3. Selecteer QIR Adaptive RI.

Zodra u het target profiel hebt ingesteldQIR Adaptive RI, kunt u uw Q# programma als geïntegreerde hybride taak indienen bij Quantinuum.

1. Selecteer Weergave -> Opdrachtpalet en typ Q#: Verbinding maken met een Azure Quantum-werkruimte. Druk op Enter.
2. Selecteer het Azure-account en volg de aanwijzingen om verbinding te maken met uw voorkeursmap, abonnement en werkruimte.
3. Zodra u verbinding hebt, vouwt u in het deelvenster Explorer kwantumwerkruimten uit.
4. Vouw uw werkruimte uit en vouw de Quantinuum-provider uit.
5. Selecteer een Quantinuum beschikbaar target, bijvoorbeeld quantinuum.sim.h1-1e.
6. Selecteer het afspeelpictogram rechts van de target naam om het huidige Q# programma in te dienen.
7. Voeg een naam toe om de taak en het aantal opnamen te identificeren.
8. Druk op Enter om de taak in te dienen. De taakstatus wordt onder aan het scherm weergegeven.
9. Vouw Taken uit en beweeg de muisaanwijzer over uw taak, waarin de tijden en status van uw taak worden weergegeven.

Q# + Python

1. Wanneer u het Python-pakket qsharp gebruikt, gebruikt u de qsharp.init functie en stelt u de target_profile parameter in op Adaptive_RI.

   import qsharp
   
   qsharp.init(target_profile=qsharp.TargetProfile.Adaptive_RI)
   

2. Maak verbinding met uw Azure Quantum-werkruimte.

   import azure.quantum
   
   workspace = azure.quantum.Workspace(
       resource_id = "", # add your resource ID
       location = "", # add your location, for example "westus"
   )
   

3. Stel de target parameter in op de Quantinuum target die u wilt gebruiken. Als u bijvoorbeeld het quantinuum.sim.h1-1etargetvolgende wilt gebruiken:

   target = workspace.get_targets("quantinuum.sim.h1-1e")
   

U kunt meerdere geïntegreerde hybride taken in een sessie combineren met behulp van de target.open_session functie. Zie Aan de slag met sessies voor meer informatie.

Notitie

Hoewel sessies beschikbaar zijn voor alle kwantumcomputinghardwareproviders, ziet u dat Adaptive_RItarget profieltaken momenteel alleen worden ondersteund op Quantinuum targets.

Ondersteunde functies

De volgende tabel bevat de ondersteunde functies voor geïntegreerde hybride computing 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 geïntegreerde hybride taken, 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 de juiste feedback te krijgen bij het gebruik van Q# functies die niet target worden ondersteund.

Kopieer de volgende code naar een Q# bestand en voeg de volgende codefragmenten toe om de ondersteunde functies in actie te zien.

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
    }

}

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 geïntegreerde hybride taak schatten

U kunt de kosten voor het uitvoeren van een geïntegreerde hybride taak op Quantinuum-hardware schatten door deze eerst op een emulator uit te voeren.

Na een geslaagde uitvoering op de emulator:

1. Selecteer taakbeheer in uw Azure Quantum-werkruimte.
2. Selecteer de taak die u hebt verzonden.
3. 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.

Geïntegreerde hybride voorbeelden

De volgende voorbeelden vindt u in Q# de opslagplaats met codevoorbeelden. Ze demonstreren de huidige functieset voor geïntegreerde hybride computing.

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 voorbeeld*-programma 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.

*Deze voorbeeldcode is geschreven door leden van het TEAM van MICROSOFT Quantum in Australië en valt onder een MIT-licentie. Het is erop gericht om 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.

Gerelateerde inhoud

• Gedistribueerde hybride computing.
• Interactieve kwantumcomputing: sessies