Udostępnij za pośrednictwem

Uruchamianie hybrydowych zadań obliczeń kwantowych przy użyciu profilu adaptacyjnego target

  • Artykuł

Obliczenia hybrydowe łączą klasyczne i kwantowe procesy obliczeniowe w celu rozwiązywania złożonych problemów.

W przypadku obliczeń hybrydowych klasyczny kod kontroluje wykonywanie operacji kwantowych na podstawie pomiarów obwodu środkowego, podczas gdy fizyczne kubity pozostają aktywne. Do uruchamiania złożonych problemów można użyć typowych technik programowania, takich jak zagnieżdżone instrukcje warunkowe, pętle i wywołania funkcji, w jednym programie kwantowym, co zmniejsza liczbę potrzebnych zdjęć. Dzięki technikom ponownego użycia kubitów większe programy mogą być uruchamiane na maszynach przy użyciu mniejszej liczby kubitów.

W tym artykule wyjaśniono, jak przesyłać zadania hybrydowe do usługi Azure Quantum przy użyciu QIR Adaptive RItarget profilu. Profil adaptacyjnego wystąpienia zarezerwowanego target oferuje obsługę pomiarów obwodu środkowego, przepływu sterowania opartego na pomiarach, resetowania kubitów i klasycznych obliczeń całkowitych.

Wymagania wstępne

  • Konto platformy Azure z aktywną subskrypcją. Jeśli nie masz konta platformy Azure, zarejestruj się bezpłatnie i zarejestruj się w celu korzystania z subskrypcji z płatnością zgodnie z rzeczywistym użyciem.
  • Obszar roboczy usługi Azure Quantum. Aby uzyskać więcej informacji, zobacz Tworzenie obszaru roboczego usługi Azure Quantum.
  • Jeśli chcesz przesłać Q# programy autonomiczne, potrzebne są następujące wymagania wstępne:
  • Jeśli wan przesłać python + Q# programy, potrzebne są następujące wymagania wstępne:

    • Środowisko języka Python z zainstalowanym językiem Python i programem .

    • Usługa Azure Quantum azure-quantum i qsharp pakiety.

      pip install --upgrade azure-quantum qsharp

Obsługiwane targets

Aby uruchomić hybrydowe zadania obliczeń kwantowych, musisz wybrać dostawcę kwantowego obsługującego profil adaptacyjnego wystąpienia target zarezerwowanego.

Obecnie profil adaptacyjny target w usłudze Azure Quantum jest obsługiwany w aplikacji Quantinuumtargets.

Przesyłanie zadań adaptacyjnego wystąpienia zarezerwowanego

Aby przesłać hybrydowe zadania obliczeń kwantowych, należy skonfigurować target profil jako QIR Adaptive RI, gdzie wystąpienia zarezerwowane to "qubit Reset i Integer computations".

Profil QIR Adaptive RItarget oferuje obsługę pomiarów średniego obwodu, przepływu sterowania opartego na pomiarach, resetowania kubitów i klasycznych obliczeń liczb całkowitych.

Hybrydowe zadania kwantowe można przesyłać do usługi Azure Quantum jako Q# programy autonomiczne lub Python + Q# programy. Aby skonfigurować target profil dla hybrydowych zadań kwantowych, zobacz następujące sekcje.

Aby skonfigurować target profil zadań hybrydowych w programie Visual Studio Code, wykonaj następujące kroki:

  1. Q# Otwórz program w programie Visual Studio Code.
  2. Wybierz pozycję Widok —> Paleta poleceń i wpisz Q#: Ustaw profil usługi Azure Quantum QIRtarget. Naciśnij klawisz Enter.
  3. Wybierz opcję QIR Adaptive RI.

Po ustawieniu QIR Adaptive RI jako target profilu możesz przesłać Q# program jako zadanie hybrydowego kwantowego do aplikacji Quantinuum.

  1. Wybierz pozycję Widok —> Paleta poleceń i wpiszQ# : Połącz się z obszarem roboczym usługi Azure Quantum. Naciśnij klawisz Enter.
  2. Wybierz pozycję Konto platformy Azure i postępuj zgodnie z monitami, aby nawiązać połączenie z preferowanym katalogiem, subskrypcją i obszarem roboczym.
  3. Po nawiązaniu połączenia w okienku Eksplorator rozwiń węzeł Obszary robocze kwantowe.
  4. Rozwiń obszar roboczy i rozwiń dostawcę Quantinuum .
  5. Wybierz dowolny dostępny targetkwantinuum , na przykład quantinuum.sim.h1-1e.
  6. Wybierz ikonę odtwarzania po prawej stronie nazwy, aby rozpocząć przesyłanie bieżącego target Q# programu.
  7. Dodaj nazwę, aby zidentyfikować zadanie i liczbę zdjęć.
  8. Naciśnij Enter, aby przesłać zadanie. Stan zadania jest wyświetlany w dolnej części ekranu.
  9. Rozwiń węzeł Zadania i umieść kursor nad zadaniem, co spowoduje wyświetlenie czasów i stanu zadania.

Obsługiwane funkcje

Poniższa tabela zawiera listę obsługiwanych funkcji hybrydowych obliczeń kwantowych za pomocą funkcji Quantinuum w usłudze Azure Quantum.

Obsługiwana funkcja Uwagi
Wartości dynamics Wartości logiczne i liczby całkowite, których wartość zależy od wyniku pomiaru
Pętle Tylko pętle ograniczone klasycznie
Dowolny przepływ sterowania Używanie rozgałęziania if/else
Pomiar obwodu środkowego Korzysta z klasycznych zasobów rejestru
Ponowne użycie kubitu Obsługiwane
Obliczenia klasyczne w czasie rzeczywistym 64-bitowa liczba całkowita ze znakiem arytmetycznym
Korzysta z klasycznych zasobów rejestru

Zestaw QDK udostępnia target- specyficzne opinie, gdy Q# funkcje języka nie są obsługiwane dla wybranego targetelementu . Jeśli program Q# zawiera nieobsługiwane funkcje podczas uruchamiania hybrydowych zadań kwantowych, w czasie projektowania zostanie wyświetlony komunikat o błędzie. Aby uzyskać więcej informacji, zobacz stronę typu wiki QIR.

Uwaga

Musisz wybrać odpowiedni QIR Adaptive RItarget profil, aby uzyskać odpowiednią opinię w przypadku korzystania z Q# funkcji, które target nie są obsługiwane.

Aby wyświetlić obsługiwane funkcje w działaniu, skopiuj poniższy kod do Q# pliku i dodaj kolejne fragmenty kodu.

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
}

Kwantinuum obsługuje dynamiczne wartości logiczne i liczby całkowite, co oznacza wartości logiczne i liczby całkowite, które zależą od wyników pomiaru. Należy pamiętać, że r0 jest to Result typ, który może służyć do generowania dynamicznych wartości logicznych i liczb całkowitych.

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

Funkcja Quantinuum obsługuje dynamiczne wartości logiczne i liczby całkowite, jednak nie obsługuje wartości dynamicznych dla innych typów danych, takich jak podwójne. Skopiuj następujący kod, aby zobaczyć opinię na temat ograniczeń wartości dynamicznych.

        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

Mimo że wartości dynamiczne nie są obsługiwane w przypadku niektórych typów danych, te typy danych mogą być nadal używane z wartościami statycznymi.

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

Nawet dynamiczne wartości obsługiwanego typu nie mogą być używane w pewnych sytuacjach. Na przykład quantinuum nie obsługuje tablic dynamicznych, czyli tablic, których rozmiar zależy od wyniku pomiaru. Firma Quantinuum nie obsługuje również pętli dynamicznie powiązanych. Skopiuj następujący kod, aby zobaczyć ograniczenia wartości dynamicznych.

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

Firma Quantinuum obsługuje przepływ sterowania, w tym if/else rozgałęzianie, przy użyciu warunków statycznych i dynamicznych. Rozgałęzianie w warunkach dynamicznych jest również nazywane rozgałęzianiem na podstawie wyników pomiaru.

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

Funkcja Quantinuum obsługuje pętle z klasycznymi warunkami i w tym if wyrażeniami.

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

Kwantinuum obsługuje pomiar średniego obwodu, czyli rozgałęzianie na podstawie wyników pomiaru.

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

Szacowanie kosztów zadania hybrydowego przetwarzania kwantowego

Możesz oszacować koszt uruchamiania hybrydowego zadania obliczeń kwantowych na sprzęcie Firmy Quantinuum, uruchamiając go najpierw w emulatorze.

Po pomyślnym uruchomieniu w emulatorze:

  1. W obszarze roboczym usługi Azure Quantum wybierz pozycję Zarządzanie zadaniami.
  2. Wybierz przesłane zadanie.
  3. W oknie podręcznym Szczegóły zadania wybierz pozycję Szacowanie kosztów, aby wyświetlić liczbę używanych jednostek eHQC (środki emulatora Quantinuum). Ta liczba przekłada się bezpośrednio na liczbę HQCs (kwantowych kredytów kwantowych Kwantowych), które są potrzebne do uruchomienia zadania na sprzęcie Quantinuum.

Oszacowanie kosztów

Uwaga

Kwantinuum wyrejestruje cały obwód i oblicza koszt dla wszystkich ścieżek kodu, niezależnie od tego, czy są one wykonywane warunkowo, czy nie.

Przykłady hybrydowych obliczeń kwantowych

Poniższe przykłady można znaleźć w Q# repozytorium przykładów kodu. Demonstrują one bieżący zestaw funkcji dla hybrydowego przetwarzania kwantowego.

Kod powtórzeń z trzema kubitami

W tym przykładzie pokazano, jak utworzyć kod powtórzenia z trzema kubitami, który może służyć do wykrywania i poprawiania błędów przerzucania bitów.

Wykorzystuje zintegrowane funkcje przetwarzania hybrydowego w celu zliczania liczby wykonanych poprawek błędów, gdy stan rejestru kubitów logicznych jest spójny.

Przykładowy kod można znaleźć tutaj.

Iteracyjne szacowanie fazy

Ten przykładowy program demonstruje iteracyjne szacowanie fazy w programie Q#. Używa iteracyjnego szacowania fazy do obliczania produktu wewnętrznego między dwoma dwuwymiarowymi wektorami zakodowanymi na kubitie target i kubitem ancilla. Dodatkowy kubit kontrolny jest również inicjowany, który jest jedynym kubitem używanym do pomiaru.

Obwód zaczyna się od kodowania pary wektorów na kubitie target i kubitu ancilla. Następnie stosuje operator Oracle do całego rejestru, kontrolowanego od kubitu sterującego, który jest skonfigurowany w stanie $\ket +$. Kontrolowany operator Oracle generuje fazę stanu $\ket 1$ kubitu sterującego. Następnie można to odczytać, stosując bramę H do kubitu sterującego, aby można było zaobserwować fazę podczas pomiaru.

Przykładowy kod można znaleźć tutaj.

Uwaga

Ten przykładowy kod został napisany przez członków zespołu KPMG Quantum w Australii i podlega licencji MIT. Demonstruje rozszerzone możliwości QIR Adaptive RItargets i wykorzystuje ograniczone pętle, klasyczne wywołania funkcji w czasie wykonywania, zagnieżdżone instrukcje warunkowe if, pomiary obwodu środkowego i ponowne użycie kubitu.

Powiązana zawartość