Övning – Kom igång med Microsoft Quantum-resursberäknaren

8 minuter

I föregående lektion lärde du dig att Microsoft Quantum-resursberäknaren tar tre huvudsakliga indataparametrar: de fysiska kvantbitsparametrarna, QEC-schemat (Quantum Error Correction) och felbudgeten.

Nu ska vi öva på resursestimatorn. I den här lektionen använder du resursberäknaren för att uppskatta de fysiska resurskraven för ett enkelt kvantprogram.

Installera de paket som krävs

Om du vill använda resursberäknaren installerar du det senaste qdk Python-biblioteket med jupyter det extra från Microsoft Quantum Development Kit (QDK).

python -m pip install --upgrade "qdk[jupyter]"

Om du inte redan har installerat QDK-tillägget för Visual Studio Code (VS Code) läser du Installera QDK-tillägget.

Skapa kvantalgoritmen i en Jupyter-notebook-fil

Nu ska vi skriva kvantalgoritmen i en Jupyter-anteckningsbok. Följ dessa steg för att skapa en Jupyter-notebook-fil med QDK i VS Code:

Öppna VS Code.
Öppna menyn Visa och välj sedan Kommandopalett. En indataruta visas.
I inmatningsrutan anger du och väljer Skapa: Ny Jupyter Notebook.
Importera qsharp-paketet och EstimateDetails-funktionen i anteckningsbokens första cell.
```
import qsharp
from qsharp_widgets import EstimateDetails
```
Välj knappen + Kod för att lägga till en ny cell.

Kopiera följande RandomBit kod till den nya cellen:

%%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 accessible 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;
    }

Beräkna resurser för kvantalgoritmen

Kör resursberäknaren för att uppskatta de fysiska resurser som behövs för att köra RandomBit åtgärden. Om du inte anger några parametrar använder resursberäknaren följande standardparametervärden:

qubit_gate_ns_e3 för qubitmodellen
surface_code för felkorrigeringskoden
0.001 för felbudgeten

Följ dessa steg för att köra resursestimatorn:

Lägg till en ny cell och kopiera följande kod till cellen:
```
result = qsharp.estimate("RandomBit()")

EstimateDetails(result)
```
Funktionen qsharp.estimate skapar ett resultatobjekt som innehåller information från resursberäknaren. Vi skickar result till EstimateDetails funktionen som visar en uppsättning tabeller i listrutor som innehåller utdata från resursberäknaren.
Expandera den första tabellen med namnet Fysiska resursberäkningar. Den här tabellen visar körningen, de tillförlitliga kvantåtgärderna per sekund och antalet kvantbitar som krävs för att köra algoritmen.

Uppskattning av fysisk resurs Värde

Körtid 2 mikrosek

rQOPS 3,00 M

Fysiska kvantbitar 300

Åtgärden RandomBit kräver 300 fysiska kvantbitar och det tar två mikrosekunder att köras.
Välj listrutan Fysiska resursuppskattningar igen för att dölja tabellen.

Uppskattning av fysisk resurs	Värde
Körtid	2 mikrosek
rQOPS	3,00 M
Fysiska kvantbitar	300

Om du vill granska de andra tabellerna väljer du en listruta för att expandera motsvarande tabell. Välj till exempel listrutan Logiska qubitparametrar . Den här tabellen visar att kodavståndet är 5 och att det finns 50 fysiska kvantbitar per logisk qubit.

Logisk qubit-parameter	Värde
QEC-schema	`surface_code`
Kodavstånd	5
Fysiska kvantbitar	50
Logisk cykeltid	2 mikrosek
Felfrekvens för logisk kvantbit	3.00E-5
Korsningsförfaktor	0.03
Tröskelvärde för felkorrigering	0.01
Formel för logisk cykeltid	(4 * `twoQubitGateTime` + 2 * `oneQubitMeasurementTime`) * `codeDistance`
Formel för fysiska kvantbitar	2 * `codeDistance` * `codeDistance`

Använd fältet jobParams för att komma åt alla målparametrar som du kan skicka till jobbet och för att undersöka standardvärdena för parametrar som du inte anger. Skapa en ny cell och kopiera följande kod till cellen:
```
result['jobParams']
```

Kör den nya cellen och inspektera utdata:

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

För den här algoritmen använder resursberäknaren qubit_gate_ns_e3 qubitmodellen, felkorrigeringskoden surface_code och 0,001 för felbudgeten. Det här är standardvärdena för dessa parametrar eftersom du inte angav deras värden när du anropade resursestimatorn.

Ändra standardvärdena och beräkna resurserna igen

Om du vill köra uppskattningen med andra parametervärden än standardvärdena anger du andra värden för parametrar när du anropar resursberäknaren. Nu ska vi ändra qubitmodellen, QEC-schemat och felbudgeten.

Ändra qubitmodellen

Beräkna kostnaden för att köra samma algoritm på en Majorana-dator. Det gör du genom att skicka parametern qubitParams med fältet name inställt på qubit_maj_ns_e6 när du anropar resursberäknaren.

I en ny cell kopierar och kör du följande kod:

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

EstimateDetails(result_maj)

Öppna rullgardinsmenyerna i resultatet för att utforska hur resurskostnaderna skiljer sig åt för Majorana-datorn jämfört med den portbaserade datorn.

Ändra QEC-schemat

Därefter beräknar du kostnaden för samma algoritm på en Majorana-dator med ett Floquet QEC-schema. Det gör du genom att skicka parametern qecScheme med fältet name inställt på floquet_code när du anropar resursberäknaren.

I en ny cell kopierar och kör du följande kod:

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

EstimateDetails(result_maj)

Expandera listrutorna i utdata för att utforska hur resurskostnaderna skiljer sig åt för Floquet QEC-schemat jämfört med ytkodschemat.

Ändra felbudgeten

Slutligen beräknar du kostnaden för samma parametrar som din tidigare uppskattning, men ökar felbudgeten till 10%. För att göra detta skickar du parametern errorBudget med värdet inställt på 0.1 när du anropar resursestimatorn.

I en ny cell kopierar och kör du följande kod:

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

EstimateDetails(result_maj)

Grattis! Du har använt resursberäknaren för att uppskatta de fysiska resurser som krävs för att köra en enkel kvantalgoritm. Du har också anpassat parametrarna för att se hur de påverkar resursuppskattningarna.

I nästa lektion beräknar du de resurser som behövs för ett mycket mer komplext kvantprogram: Shor-algoritmen.

Feedback

Var den här sidan till hjälp?