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

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 Adaptive RItarget profilu. Profil Adaptive RItarget oferuje obsługę pomiarów średniego obwodu, przepływu sterowania opartego na pomiarach, resetowania kubitów i klasycznych obliczeń liczb całkowitych.

Wymagania wstępne

• Konto platformy Azure z aktywną subskrypcją. Jeśli nie masz konta platformy Azure, zarejestruj się za darmo i zapisz się na subskrypcję płatną zgodnie z wykorzystaniem.
• 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ą również następujące wymagania wstępne:

• Program Visual Studio Code (VS Code) z zainstalowanym rozszerzeniem Quantum Development Kit Azure (QDK).
• Najnowsza wersja rozszerzeniaQuantum Development KitAzure.

Jeśli chcesz przesłać język Python i Q# programy, potrzebne są również następujące wymagania wstępne:

• Środowisko Python z zainstalowanym Pythonem i Pipem.

• Najnowsza qdk biblioteka języka Python z opcjonalnym azure dodatkiem.

  pip install --upgrade "qdk[azure]"
  

Obsługiwane targets

Aby uruchomić hybrydowe zadania obliczeń kwantowych, musisz wybrać dostawcę kwantowego obsługującego Adaptive RItarget profil.

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

Przesyłanie adaptacyjnych zadań RI.

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

Profil 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 programy autonomiczne Q# lub programy Python + Q#. Aby skonfigurować target profil dla hybrydowych zadań kwantowych, zobacz następujące sekcje.

Obsługiwane funkcje

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

Zestaw QDK udostępnia target-specyficzne informacje zwrotne, gdy Q# funkcje językowe nie są obsługiwane dla wybranego target. Jeśli program Q# zawiera nieobsługiwane funkcje, podczas uruchamiania hybrydowych zadań kwantowych zostanie wyświetlony komunikat o błędzie przed rozpoczęciem działania. Aby uzyskać więcej informacji, zobacz QIR stronę typu wiki.

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

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
}

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 wartości dynamiczne wspieranego 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);
    }

Quantinuum obsługuje pętle z klasycznymi warunkami, w tym wyrażenia if.

    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 uruchomienia hybrydowego zadania obliczeń kwantowych na sprzęcie Firmy Quantinuum, uruchamiając najpierw zadanie 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ć, ile jednostek eHQC (środki emulatora Quantinuum) zostało wykorzystanych. Ta liczba przekłada się bezpośrednio na liczbę kwantowych kredytów Quantinuum (HQC), które są potrzebne do uruchomienia zadania na sprzęcie Quantinuum.

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ć trzykubitowy kod powtórzeń, który może służyć do wykrywania i poprawiania błędów inwersji 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.

Kod można znaleźć w tym przykładzie.

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 przez kubit sterujący, 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.

Kod można znaleźć w tym przykładzie.

Powiązana zawartość

• Wprowadzenie do sesji