Freigeben über

Ausführen von Hybrid-Quantencomputing-Aufträgen mit adaptivem target Profil

  • Artikel

Hybrid Computing kombiniert klassische und Quantencomputingprozesse, um komplexe Probleme zu lösen.

Im Hybrid computing steuert der klassische Code die Ausführung von Quantenvorgängen basierend auf Mid-Circuit-Messungen, während die physischen Qubits aktiv bleiben. Sie können gängige Programmiertechniken wie geschachtelte Bedingte, Schleifen und Funktionsaufrufe in einem einzigen Quantenprogramm verwenden, um komplexe Probleme auszuführen und die Anzahl der benötigten Aufnahmen zu verringern. Mit qubit-Wiederverwendungstechniken können größere Programme auf Computern mit einer kleineren Anzahl von Qubits ausgeführt werden.

In diesem Artikel wird erläutert, wie Sie Hybridaufträge mithilfe des QIR Adaptive RItarget Profils an Azure Quantum übermitteln. Das adaptive RI-Profil target bietet Unterstützung für Mid-Circuit-Messungen, messbasierte Steuerungsfluss, Qubit-Zurücksetzung und klassische Ganzzahlberechnung.

Voraussetzungen

Unterstützung von targets

Um Hybrid-Quantencomputing-Aufträge auszuführen, müssen Sie einen Quantenanbieter auswählen, der das adaptive RI-Profil targetunterstützt.

Derzeit wird adaptives target Profil in Azure Quantum auf Quantinuumtargets unterstützt.

Übermitteln adaptiver RI-Aufträge

Um Hybrid-Quantencomputing-Aufträge zu übermitteln, müssen Sie das target Profil so QIR Adaptive RIkonfigurieren, dass RI für "qubit Reset und Integer computations"steht.

Das QIR Adaptive RItarget Profil bietet Unterstützung für Mid-Circuit-Messungen, messbasierte Steuerungsfluss, Qubit-Rücksetzung und klassische Ganzzahlberechnung.

Sie können Hybrid-Quantenaufträge als Q# eigenständige Programme oder Python+ Q# -Programme an Azure Quantum übermitteln. Informationen zum Konfigurieren des target Profils für hybride Quantenaufträge finden Sie in den folgenden Abschnitten.

Führen Sie die folgenden Schritte aus, um das target Profil für Hybridaufträge in Visual Studio Code zu konfigurieren:

  1. Öffnen Sie ein Q# Programm in Visual Studio Code.
  2. Wählen Sie Ansicht -> Befehlspalette und Typ Q# aus: Legen Sie das Azure Quantum QIRtarget Profil fest. Drücken Sie die EINGABETASTE.
  3. Wählen Sie QIR Adaptive RI aus.

Nachdem Sie als Profil festgelegt QIR Adaptive RI haben, können Sie Ihr Q# Programm als hybriden Quantenauftrag an Quantinuum target übermitteln.

  1. Wählen Sie "Ansicht " - Befehlspalette aus, und geben Sie Folgendes einQ#: Verbinden mit einem Azure Quantum-Arbeitsbereich.> Drücken Sie die EINGABETASTE.
  2. Wählen Sie Azure-Konto aus, und folgen Sie den Anweisungen, um eine Verbindung mit Ihrem bevorzugten Verzeichnis, Abonnement und Arbeitsbereich herzustellen.
  3. Sobald Sie verbunden sind, erweitern Sie im Explorer-Bereich Quantum Workspaces.
  4. Erweitern Sie Ihren Arbeitsbereich, und erweitern Sie den Quantinuum-Anbieter .
  5. Wählen Sie einen beliebigen verfügbaren targetQuantinuum aus, z . B. quantinuum.sim.h1-1e.
  6. Wählen Sie rechts neben dem target Namen das Wiedergabesymbol aus, um mit der Übermittlung des aktuellen Q# Programms zu beginnen.
  7. Fügen Sie einen Namen hinzu, um den Auftrag und die Anzahl der Aufnahmen zu identifizieren.
  8. Drücken Sie die EINGABETASTE, um den Auftrag zu senden. Der Auftragsstatus wird unten auf dem Bildschirm angezeigt.
  9. Erweitern Sie Aufträge, und zeigen Sie mit der Maus auf Ihren Auftrag. Dadurch werden die Anzahl und der Status Ihres Auftrags angezeigt.

Unterstützte Funktionen

In der folgenden Tabelle sind die unterstützten Features für hybrides Quanten computing mit Quantinuum in Azure Quantum aufgeführt.

Unterstützte Funktion Hinweise
Dynamics-Werte Boolesche und ganze Zahlen, deren Wert von einem Messergebnis abhängt
Schleifen Nur klassisch gebundene Schleifen
Beliebiger Kontrollfluss Verwendung der If/Else-Verzweigung
Mid-Circuit-Messung Verwendet klassische Registerressourcen
Wiederverwendung von Qubit Unterstützt
Klassische Berechnung in Echtzeit 64-Bit-Ganzzahlarithmetik mit Vorzeichen
Verwendet klassische Registerressourcen

Der QDK stellt -spezifisches Feedback bereit target, wenn Q# Sprachfeatures für die ausgewählte Option targetnicht unterstützt werden. Wenn Ihr Q# Programm nicht unterstützte Features enthält, wenn hybride Quantenaufträge ausgeführt werden, erhalten Sie zur Entwurfszeit eine Fehlermeldung. Weitere Informationen finden Sie auf der Wiki-Seite QIR.

Hinweis

Sie müssen das entsprechende QIR Adaptive RItarget Profil auswählen, um entsprechendes Feedback zu erhalten, wenn Sie Features verwenden Q# , die nicht target unterstützt werden.

Um die unterstützten Features in Aktion anzuzeigen, kopieren Sie den folgenden Code in eine Q# Datei, und fügen Sie die nachfolgenden Codeausschnitte hinzu.

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 unterstützt dynamische Boolesche und ganze Zahlen, was bedeutet, dass Boolesche und ganze Zahlen, die von den Messergebnissen abhängen. Beachten Sie, dass r0 es sich um einen Result Typ handelt, der zum Generieren dynamischer Bool- und ganzzahliger Werte verwendet werden kann.

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

Quantinuum unterstützt dynamische Boolesche und ganze Zahlen, unterstützt jedoch keine dynamischen Werte für andere Datentypen, z. B. Double. Kopieren Sie den folgenden Code, um Feedback zu den Einschränkungen dynamischer Werte anzuzeigen.

        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

Obwohl dynamische Werte für einige Datentypen nicht unterstützt werden, können diese Datentypen weiterhin mit statischen Werten verwendet werden.

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

Auch dynamische Werte unterstützter Typs können in bestimmten Situationen nicht verwendet werden. Beispielsweise unterstützt Quantinuum keine dynamischen Arrays, d. h. Arrays, deren Größe von einem Messergebnis abhängt. Quantinuum unterstützt auch keine dynamisch gebundenen Schleifen. Kopieren Sie den folgenden Code, um die Einschränkungen dynamischer Werte anzuzeigen.

        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 unterstützt den Steuerungsfluss, einschließlich if/else Verzweigung, unter Verwendung statischer und dynamischer Bedingungen. Verzweigung auf dynamischen Bedingungen wird auch als Verzweigung basierend auf Messergebnissen bezeichnet.

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

Quantinuum unterstützt Schleifen mit klassischen Bedingungen und einschließlich if Ausdrücken.

        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 unterstützt die Mid-Circuit-Messung, d. h. Verzweigung basierend auf Messergebnissen.

        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);
        }

Schätzen der Kosten eines hybriden Quantencomputingauftrags

Sie können die Kosten für die Ausführung eines Hybrid-Quantencomputingauftrags auf Quantinuum-Hardware schätzen, indem Sie ihn zuerst auf einem Emulator ausführen.

Nach erfolgreicher Ausführung im Emulator:

  1. Wählen Sie in Ihrem Azure Quantum-Arbeitsbereich "Auftragsverwaltung" aus.
  2. Wählen Sie den Auftrag aus, den Sie übermittelt haben.
  3. Wählen Sie im Popup "Auftragsdetails " die Option "Kostenschätzung " aus, um anzuzeigen, wie viele eHQCs (Quantinuum Emulatorguthaben) verwendet wurden. Diese Zahl wird direkt in die Anzahl der HQCs (Quantinuum Quantum Credits) übersetzt, die zum Ausführen des Auftrags auf Quantinuum-Hardware erforderlich sind.

Kostenvorkalkulation

Hinweis

Quantinuum hebt die Registrierung des gesamten Schaltkreises auf und berechnet die Kosten für alle Codepfade, unabhängig davon, ob sie bedingt ausgeführt werden oder nicht.

Hybride Quantencomputingbeispiele

Die folgenden Beispiele finden Sie im Q# Codebeispiel-Repository. Sie veranschaulichen den aktuellen Featuresatz für hybride Quantencomputing.

Drei-Qubit-Wiederholungscode

In diesem Beispiel wird veranschaulicht, wie Sie einen Drei-Qubit-Wiederholungscode erstellen, mit dem Bit-Flip-Fehler erkannt und korrigiert werden können.

Es nutzt integrierte Hybrid computing-Features, um zu zählen, wie oft fehlerkorrektur durchgeführt wurde, während der Zustand eines logischen Qubit-Registers kohärent ist.

Hier finden Sie das Codebeispiel.

Iterative Phasenschätzung

Dieses Beispielprogramm veranschaulicht eine iterative Phasenschätzung innerhalb Q#von . Es verwendet iterative Phasenschätzung, um ein inneres Produkt zwischen zwei zweidimensionalen Vektoren zu berechnen, die auf einem target Qubit und einem Ancilla-Qubit codiert sind. Ein zusätzliches Steuerelement-Qubit wird auch initialisiert, was das einzige qubit ist, das für die Messung verwendet wird.

Der Schaltkreis beginnt mit der Codierung des Vektorpaars auf dem target Qubit und dem Ancilla-Qubit. Anschließend wendet er einen Oracle-Operator auf das gesamte Register an, gesteuert vom Steuer-Qubit, das im Zustand $\ket +$ eingerichtet ist. Der kontrollierte Oracle-Operator generiert eine Phase im $\ket 1$-Zustand des Kontroll qubits. Dies kann dann gelesen werden, indem ein H-Tor auf das Steuer qubit angewendet wird, um die Phase beim Messen feststellbar zu machen.

Hier finden Sie das Codebeispiel.

Hinweis

Dieser Beispielcode wurde von Mitgliedern des QUANTUM-Teams in Australien geschrieben und fällt unter eine MIT-Lizenz. Es veranschaulicht erweiterte Funktionen von QIR Adaptive RItargets gebundenen Schleifen, klassische Funktionsaufrufe zur Laufzeit, geschachtelte bedingte If-Anweisungen, Mid-Circuit-Messungen und Wiederverwendung von Qubits.

Zugehöriger Inhalt