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 geschachtelte Bedingungsanweisungen, Schleifen und Funktionsaufrufe in einem einzigen Quantenprogramm verwenden, um komplexe Probleme zu lösen und die Anzahl der benötigten Durchläufe 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 Adaptive RItarget Profils an Azure Quantum übermitteln. Das Adaptive RItarget Profil bietet Unterstützung für Mid-Circuit-Messungen, messbasierter Steuerfluss, Qubit-Rücksetzung und klassische Ganzzahlberechnung.

Voraussetzungen

Wenn Sie eigenständige Programme übermitteln Q# möchten, benötigen Sie auch die folgende Voraussetzung:

Wenn Sie Python und Q# Programme übermitteln möchten, benötigen Sie auch die folgenden Voraussetzungen:

  • Eine Python-Umgebung mit installiertem Python und Pip.

  • Die neueste qdk Python-Bibliothek mit dem optionalen azure Zusatz.

    pip install --upgrade "qdk[azure]"

Unterstützung von targets

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

Derzeit wird das adaptive 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 Adaptive RIkonfigurieren, dass RI für "qubit Reset und Integer computations"steht.

Das Adaptive RItarget Profil bietet Unterstützung für Mid-Circuit-Messungen, messbasierten Steuerfluss, Qubit-Rücksetzung und klassische Integerberechnung.

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.

Um das target Profil für Hybridaufträge in Visual Studio Code zu konfigurieren, wählen Sie eine der folgenden Optionen aus:

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

  • Wenn Die Q# Datei Teil eines Q# Projekts ist, fügen Sie der Projektdatei qsharp.json Folgendes hinzu:

    {
  "targetProfile": "adaptive_ri"
}

Wenn Sie Ihr target Profil auf Adaptive RIfestlegen, können Sie Ihr Q# Programm als hybriden Quantenauftrag an Quantinuum übermitteln. Führen Sie dazu die folgenden Schritte aus:

  1. Öffnen Sie das Menü "Ansicht ", und wählen Sie "Befehlspalette" aus, geben Sie QDK ein: Stellen Sie eine Verbindung mit einem Azure Quantum-Arbeitsbereich her, und drücken Sie dann 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. Nachdem Sie verbunden sind, erweitern Sie im Explorer-BereichQuantum-Arbeitsbereiche.
  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.h2-1e.
  6. Wählen Sie rechts neben dem target Namen das Wiedergabesymbol aus, um mit der Übermittlung des aktuellen Q# Programms zu beginnen.
  7. Geben Sie einen Namen ein, um den Auftrag zu identifizieren, und die Anzahl der Aufnahmen.
  8. Drücken Sie die EINGABETASTE, um den Auftrag zu senden. Der Auftragsstatus wird unten auf dem Bildschirm angezeigt.
  9. Erweitern Sie Jobs, und zeigen Sie mit der Maus auf Ihre Aufträge, wodurch die Zeiten und der Status Ihres Auftrags angezeigt werden.

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
Zwischenkreismessung Verwendet klassische Registerressourcen
Wiederverwendung von Qubit Unterstützt
Klassische Berechnung in Echtzeit 64-Bit-Ganzzahlarithmetik mit Vorzeichen, verwendet klassische Registerressourcen

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

Hinweis

Sie müssen das passende Adaptive RItarget Profil auswählen, um geeignetes 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 Ganzzahlen, was bedeutet, dass Boolesche Werte und Ganzzahlen von Messergebnissen abhängen können. 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 Werte und Ganzzahlen, jedoch keine dynamischen Werte für andere Datentypen, wie etwa Doppel. 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 Typen können in bestimmten Situationen nicht verwenden 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, das heißt, die Verzweigung erfolgt basierend auf den 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 hybriden Quantencomputingauftrags auf Quantinuum-Hardware schätzen, 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 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 rollt die gesamte Schaltung auf und berechnet die Kosten für alle Programmpfade, unabhängig davon, ob sie bedingt ausgeführt werden oder nicht.

Hybride Quantencomputingbeispiele

Die folgenden Beispiele finden Sie im Q# Codebeispiel-Repository. Sie zeigen die aktuellen Funktionen des hybriden 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.

Sie finden den Code in diesem Beispiel.

Iterative Phasenschätzung

Dieses Beispielprogramm veranschaulicht eine iterative Phasenschätzung innerhalb von 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. 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 es einen Oracle-Operator auf das gesamte Register an, kontrolliert durch das Kontroll-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.

Sie finden den Code in diesem Beispiel.

Hinweis

Dieser Beispielcode wurde von Mitgliedern des QUANTUM-Teams in Australien geschrieben und fällt unter eine MIT-Lizenz. Es veranschaulicht die erweiterten Möglichkeiten von Adaptive RItargets und verwendet gebundene Schleifen, klassische Funktionsaufrufe zur Laufzeit, geschachtelte if-Anweisungen, mid-circuit Messungen und die Wiederverwendung von Qubits.

Zugehöriger Inhalt

  • Last updated on