Ausführen von Hybrid-Quantencomputeraufträgen mit einem adaptiven target Profil

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 verschachtelte Bedingungen, Schleifen und Funktionsaufrufe in einem einzigen Quantenprogramm verwenden, um komplexe Programme mit weniger Shots auszuführen. 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 Adaptive RItarget-Profils an Azure Quantum übermitteln. Das Adaptive RItarget Profil unterstützt Mid-Circuit-Messungen, messungsbasierte Ablaufsteuerung, Qubitzurücksetzung und klassische Ganzzahlberechnung.

Voraussetzungen

Um eigenständige Programme zu übermitteln Q# , benötigen Sie auch die folgenden Voraussetzungen:

Um Python und Q# Programme zu übermitteln, benötigen Sie auch die folgenden Voraussetzungen:

  • Eine Python-Umgebung, in der Python und Pip installiert ist.

  • Das neueste qdkPython Paket mit dem optionalen azure Extra.

    pip install --upgrade "qdk[azure]"
    

Unterstützung von targets

Um Hybrid-Quantencomputing-Aufträge auszuführen, wählen Sie einen Quantenanbieter aus, der das Adaptive RItarget Profil unterstützt.

Quantinuum targets unterstützen derzeit dastargetAdaptive RIProfil in Azure Quantum.

Übermitteln adaptiver RI-Aufträge

Um Hybrid-Quantencomputing-Aufträge zu übermitteln, legen Sie das target Profil auf Adaptive RI, wobei RI für "qubit Reset und Integer computations" steht.

Das Adaptive RItarget Profil unterstützt Mid-Circuit-Messungen, messungsbasierten Kontrollfluss, Qubitzurücksetzung und klassische Ganzzahlberechnung.

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

Um das target Profil für Hybridaufträge VS Codefestzulegen, wählen Sie eine der folgenden Optionen aus:

  • Wenn Ihre Q# Datei nicht Teil eines Q# Projekts ist, öffnen Sie die Datei, und geben Sie @EntryPoint(Adaptive_RI) vor dem Einstiegspunktvorgang des Programms ein.

  • Wenn Die Q# Datei Teil eines Q# Projekts ist, fügen Sie der Datei Ihres Projekts qsharp.json den folgenden Code hinzu:

    {
      "targetProfile": "adaptive_ri"
    }
    

Nachdem Sie Ihr Profil auf festgelegt haben, führen Sie die folgenden Schritte aus, um Ihr Programm als hybriden Quantenauftrag an zu übermitteln:

  1. Wählen Sie in VS CodeAnsicht> aus.
  2. Drücken Sie die QDKEingabetaste: Mit einem Azure Quantum-Arbeitsbereich verbinden.
  3. Wählen Sie Azure-Konto aus, und folgen Sie den Anweisungen, um eine Verbindung mit Ihrem bevorzugten Verzeichnis, Abonnement und Arbeitsbereich herzustellen.
  4. Um Ihre Azure Quantum Arbeitsbereiche anzuzeigen, wählen Sie das Microsoft Quantum Symbol auf der Aktivitätsleiste aus.
  5. Erweitern Sie Ihren Arbeitsbereich und erweitern Sie den Quantinuum Anbieter.
  6. Wählen Sie ein verfügbares Quantinuumtarget, wie quantinuum.sim.h2-1e.
  7. Wählen Sie das Wiedergabesymbol neben dem target Namen aus, um das aktuelle Q# Programm zu übermitteln.
  8. Geben Sie einen Namen ein, um den Auftrag zu identifizieren, und die Anzahl der Aufnahmen.
  9. Übermitteln des Auftrags. Der Auftragsstatus wird unten auf dem Bildschirm angezeigt.
  10. Erweitern Sie Jobs und zeigen Sie mit der Maus auf Ihren Auftrag, um die Zeiten und den Status anzuzeigen.

Unterstützte Funktionen

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

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

Das QDK stellt target-spezifisches Feedback bereit, wenn Q# Sprachfeatures für die ausgewählte targetOption nicht unterstützt werden. Wenn Ihr Q# Programm nicht unterstützte Features aufweist, wenn Sie Hybrid-Quantenaufträge ausführen, erhalten Sie zur Entwurfszeit eine Fehlermeldung. Weitere Informationen finden Sie auf der QIR Wiki-Seite.

Hinweis

Wählen Sie das Adaptive RItarget Profil aus, um Feedback zu erhalten, wenn Sie Q# Features verwenden, die von target nicht 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.

import Std.Measurement.*;
import Std.Math.*;
import Std.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 unterstützt dynamische boolesche Werte und ganze Zahlen, also boolesche Werte und ganze Zahlen, die von den Messergebnissen abhängen. r0 ist ein Result Typ, den Sie zum Generieren dynamischer Bool- und ganzzahliger Werte verwenden können.

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

Quantinuum unterstützt dynamische boolesche Werte und Ganzzahlen, 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 einige Datentypen dynamische Werte nicht unterstützen, können Sie diese Datentypen weiterhin mit statischen Werten verwenden.

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

Sie können in bestimmten Situationen keine dynamischen Werte unterstützter Typen verwenden. Beispielsweise unterstützt Quantinuum keine dynamischen Arrays, bei denen es sich um Arrays handelt, deren Größe von einem Messergebnis abhängt. Quantinuum unterstützt auch keine dynamisch begrenzten 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 Kontrollfluss, einschließlich if/else-Verzweigungen, mit statischen und dynamischen Bedingungen. Verzweigungen bei dynamischen Bedingungen werden auch als Verzweigungen 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, die klassische Bedingungen aufweisen und if-Ausdrücke enthalten.

    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 Mid-Circuit-Messung, d. h. Verzweigungen 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

Schätzen Sie die Kosten für die Ausführung eines hybriden Quantencomputingauftrags auf Quantinuum Hardware, indem Sie zuerst den Auftrag 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 entspricht der Anzahl der HQCs (Quantinuum Quantenguthaben), die Sie zum Ausführen des Auftrags auf Quantinuum Hardware benötigen.

Screenshot des Popups

Hinweis

Quantinuum rollt den gesamten Schaltkreis aus und berechnet die Kosten für alle Codepfade, unabhängig davon, ob sie bedingt ausgeführt werden.

Hybride Quantencomputingbeispiele

Finden Sie die folgenden Beispiele im Q# Codebeispiel-Repository. Diese Beispiele veranschaulichen den aktuellen Funktionsumfang für hybrides Quantencomputing.

Drei-Qubit-Wiederholungscode

In diesem Beispiel wird veranschaulicht, wie Sie einen Drei-Qubit-Wiederholungscode erstellen, der Bit-Flip-Fehler erkennt und korrigiert.

Es verwendet integrierte Hybrid computing-Features, um zu ermitteln, wie oft fehlerkorrektur ausgeführt wird, während der Zustand eines logischen Qubit-Registers kohärent ist.

Suchen Sie den Code im Beispiel zum Drei-Qubit-Wiederholungscode.

Iterative Phasenschätzung

Dieses Beispielprogramm veranschaulicht die iterative Phasenschätzung in Q#. 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. Das Programm initialisiert auch ein Steuerqubit, das als einziges Qubit zur 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 Kontrollqubits. Um diese Phase zu lesen, wenden Sie ein H-Gate auf das Steuerqubit an, wodurch die Phase während der Messung feststellbar wird.

Suchen Sie den Code im Beispiel zur Berechnung des Skalarprodukts mittels Phasenschätzung.

Hinweis

Mitglieder des KPMG Quantum-Teams in Australien schrieben diesen Beispielcode, der unter eine MIT-Lizenz fällt. Das Beispiel zeigt erweiterte Funktionen von Adaptive RItargets, verwendet gebundene Schleifen, klassische Funktionsaufrufe zur Laufzeit, geschachtelte bedingte if Anweisungen, Mid-Circuit-Messungen und Wiederverwendung von Qubits.