Ćwiczenie — rozpoczynanie pracy z narzędziem do szacowania zasobów usługi Azure Quantum

Ukończone

W poprzedniej lekcji przedstawiono, że narzędzie do szacowania zasobów usługi Azure Quantum działa, przyjmując trzy główne dane wejściowe: fizyczne parametry kubitu, schemat korekty błędu kwantowego (QEC) i budżet błędów.

Wypróbujmy narzędzie do szacowania zasobów usługi Azure Quantum. W tej lekcji oszacujesz zasoby fizyczne prostego programu przy użyciu narzędzia do szacowania zasobów usługi Azure Quantum.

Instalowanie wymaganych pakietów

Najpierw zainstaluj najnowszą wersję usługi Azure Quantum qsharp i qsharp-widgets pakietów.

python -m pip install --upgrade qsharp qsharp-widgets 

Tworzenie algorytmu kwantowego w notesie Jupyter

Aby rozpocząć pracę z narzędziem do szacowania zasobów, oszacowasz wymagane zasoby dla prostego algorytmu kwantowego, który generuje losowy bit.

1. Otwórz program Visual Studio Code.

2. Wybierz View > Paletę poleceń i wybierz Utwórz: Nowy Jupyter Notebook.

3. W pierwszej komórce notesu zaimportuj qsharp pakiet:

   import qsharp
   from qsharp_widgets import EstimateDetails
   

4. Dodaj nową komórkę i skopiuj następujący kod:

   %%qsharp
   /// # Sample
   /// Random Bit
   ///
   /// # Description
   /// This Q# program generates a random bit by setting a qubit in a superposition
   /// of the computational basis states |0〉 and |1〉, and returning the measurement
   /// result.
   
       operation RandomBit() : Result {
           // Qubits are only accesible for the duration of the scope where they
           // are allocated and are automatically released at the end of the scope.
           use qubit = Qubit();
   
           // Set the qubit in superposition by applying a Hadamard transformation.
           H(qubit);
   
           // Measure the qubit. There is a 50% probability of measuring either 
           // `Zero` or `One`.
           let result = M(qubit);
   
           // Reset the qubit so it can be safely released.
           Reset(qubit);
           return result;
       }
   

Szacowanie algorytmu kwantowego

Teraz uruchom narzędzie do szacowania zasobów, aby oszacować zasoby fizyczne dla operacji RandomBit. Jeśli nic nie określisz, narzędzie do szacowania zasobów używa domyślnych założeń, czyli modelu kubitu qubit_gate_ns_e3, kodu korekty błędu surface_code i budżetu błędu 0,001.

1. Dodaj nową komórkę i skopiuj następujący kod:

   result = qsharp.estimate("RandomBit()")
   result
   

   Funkcja qsharp.estimate tworzy obiekt wynikowy, który może służyć do wyświetlania tabeli z ogólną liczbą zasobów fizycznych. Pierwsza tabela przedstawia główne oszacowania zasobów fizycznych. Operacja RandomBit wymaga 300 kubitów i przyjmuje dwie mikrosekundy do uruchomienia na komputerze kwantowym.

   Szacowanie zasobów fizycznych	Wartość
   Środowisko uruchomieniowe	2 mikrosekony
   rQOPS	3,00 mln
   Kubity fizyczne	300

2. Szczegóły kosztów można sprawdzić, zwijając grupy, które zawierają więcej informacji. Na przykład zwiń grupę Parametrów kubitu logicznego, aby zobaczyć, że odległość kodu wynosi 5, a liczba kubitów fizycznych na kubit logiczny wynosi 50.

   Parametr kubitu logicznego	Wartość
   Schemat QEC	surface_code
   Odległość kodu	5
   Kubity fizyczne	50
   Czas cyklu logicznego	2 mikrosekony
   Szybkość błędów kubitu logicznego	3.00E-5
   Wstępna przeprawa	0.03
   Próg korekty błędu	0,01
   Formuła czasu cyklu logicznego	(4 * twoQubitGateTime + 2 * oneQubitMeasurementTime) * codeDistance
   Formuła kubitów fizycznych	2 * codeDistance * codeDistance

3. Za pomocą jobParams pola można uzyskać dostęp do wszystkich parametrów docelowych, które można przekazać do wykonania zadania i sprawdzić, które wartości domyślne zostały przyjęte:

   result['jobParams']
   

   {'errorBudget': 0.001,
    'qecScheme': {'crossingPrefactor': 0.03,
     'errorCorrectionThreshold': 0.01,
     'logicalCycleTime': '(4 * twoQubitGateTime + 2 * oneQubitMeasurementTime) * codeDistance',
     'name': 'surface_code',
     'physicalQubitsPerLogicalQubit': '2 * codeDistance * codeDistance'},
    'qubitParams': {'instructionSet': 'GateBased',
     'name': 'qubit_gate_ns_e3',
     'oneQubitGateErrorRate': 0.001,
     'oneQubitGateTime': '50 ns',
     'oneQubitMeasurementErrorRate': 0.001,
     'oneQubitMeasurementTime': '100 ns',
     'tGateErrorRate': 0.001,
     'tGateTime': '50 ns',
     'twoQubitGateErrorRate': 0.001,
     'twoQubitGateTime': '50 ns'}}
   

   Widać, że narzędzie do szacowania zasobów przyjmuje model kubitów qubit_gate_ns_e3, kod korekty błędu surface_code i budżet błędu 0,001, które są wartościami domyślnymi szacowania.

Zmienianie wartości domyślnych i szacowanie algorytmu

Jeśli nie chcesz używać wartości domyślnych, możesz określić parametry opcjonalne. Zmieńmy model kubitu, schemat QEC i budżet błędów.

Zmienianie modelu kubitu

Szacujesz koszt dla tego samego algorytmu przy użyciu parametru kubitu opartego na majoranie, qubit_maj_ns_e6. W tym celu należy przekazać parametr qubitParams z polem name ustawionym na qubit_maj_ns_e6.

W nowej komórce skopiuj i uruchom następujący kod:

result_maj = qsharp.estimate("RandomBit()", params={
                "qubitParams": {
                    "name": "qubit_maj_ns_e6"
                }})
EstimateDetails(result_maj)

Zmienianie schematu korekty błędów kwantowych

Szacujesz koszt przetwarzania tego samego algorytmu przy użyciu parametrów kubitu na bazie Majorany, zgodnie z teorią Floqueta, w schemacie QEC qecScheme. W tym celu należy również przekazać parametr qecScheme z polem name ustawionym na floquet_code.

W nowej komórce skopiuj i uruchom następujący kod:

result_maj = qsharp.estimate("RandomBit()", params={
                "qubitParams": {
                    "name": "qubit_maj_ns_e6"
                },
                "qecScheme": {
                    "name": "floquet_code"
                }})
EstimateDetails(result_maj)

Zmiana budżetu błędu

Następnie szacuj koszt dla tych samych parametrów przy użyciu errorBudget 10%. W tym celu należy przekazać parametr errorBudget z wartością ustawioną na 0,1.

W nowej komórce skopiuj i uruchom następujący kod:

result_maj = qsharp.estimate("RandomBit()", params={
                "qubitParams": {
                    "name": "qubit_maj_ns_e6"
                },
                "qecScheme": {
                    "name": "floquet_code"
                },
                "errorBudget": 0.1})
EstimateDetails(result_maj)

Gratulacje! Pomyślnie oszacowano zasoby fizyczne dla prostego algorytmu kwantowego przy użyciu narzędzia do szacowania zasobów usługi Azure Quantum i dostosowano parametry, aby zobaczyć, jak wpływają one na oszacowania zasobów.

W następnej lekcji zwiększysz poziom trudności i oszacujesz zasoby dla algorytmu Shora przy użyciu Azure Quantum Resource Estimator.