8 Minuten

In dieser Lerneinheit erfahren Sie mehr zum Umgang mit Azure Quantum Resource Estimator. Im folgenden Beispiel schätzen Sie die physischen Ressourcen eines Beispiels des Shor-Algorithmus.

Installieren von qsharp und qsharp-widgets

Installieren Sie zunächst das neueste Azure Quantum qsharp und qsharp-widgets die neuesten Pakete.

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

Erstellen des Quantenalgorithmus

Wählen Sie in VS Code die Optionen Ansicht > Befehlspalette und dann Erstellen aus: Verwenden von Jupyter Notebook.
Importieren Sie das qsharp-Paket in der ersten Zelle des Notebooks.
```
import qsharp
from qsharp_widgets import EstimateDetails
```

Fügen Sie eine neue Zelle hinzu und kopieren Sie den folgenden Code.

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

Schätzen des Quantenalgorithmus

Schätzen Sie nun die physischen Ressourcen für den RandomBit-Vorgang unter Verwendung der Standardannahmen. Fügen Sie eine neue Zelle hinzu und kopieren Sie den folgenden Code.
```
result = qsharp.estimate("RandomBit()")
result
```
Die qsharp.estimate-Funktion erstellt ein Ergebnisobjekt, mit dem eine Tabelle mit der Gesamtanzahl der physischen Ressourcen angezeigt werden kann. Die erste Tabelle zeigt die physischen Standard-Ressourcenschätzungen. Der RandomBit-Vorgang erfordert 300 Qubits und benötigt 2 Mikrosekunden, um auf einem Quantencomputer ausgeführt zu werden.

Physische Ressourcenschätzungen Wert

Laufzeit 2 Mikrosek.

rQOPS 3,00 M

Physische Qubits 300

Physische Ressourcenschätzungen	Wert
Laufzeit	2 Mikrosek.
rQOPS	3,00 M
Physische Qubits	300

Sie können die Kostendetails einsehen, indem Sie die Gruppen, die mehr Informationen enthalten, zuklappen. Reduzieren Sie beispielsweise die Gruppe der logischen Qubit-Parameter, um festzustellen, ob der Codeabstand 5 und die Anzahl der physischen Qubits pro logischem Qubit 50 ist.

Logischer Qubitparameter	Wert
QEC-Schema	surface_code
Codeabstand	5
Physische Qubits	50
Logische Zykluszeit	2 Mikrosek.
Fehlerrate logischer Qubits	3,00E–5
Vorfaktor der Kreuzung	0,03
Schwellenwert für die Fehlerkorrektur	0.01
Formel für die logische Zykluszeit	(4 × `twoQubitGateTime` × 2 × `oneQubitMeasurementTime`) × `codeDistance`
Formel für physische Qubits	2 × `codeDistance` * `codeDistance`

Sie können das jobParams-Feld verwenden, um auf alle Zielparameter zuzugreifen, die an die Auftragsausführung übergeben werden können, und um zu sehen, welche Standardwerte angenommen wurden:

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

Sie können sehen, dass der Ressourcen-Estimator das qubit_gate_ns_e3- Qubit-Modell, den surface_code-Fehlerkorrekturcode und das Fehlerbudget 0,001 als Standardwerte für die Schätzung verwendet.

Ändern der Standardwerte und Schätzen des Algorithmus

Beim Übermitteln einer Ressourcenschätzungsanforderung für Ihr Programm können Sie einige optionale Parameter angeben. Dies sind die Zielparameter, die angepasst werden können:

errorBudget - das zulässige Gesamtfehlerbudget für den Algorithmus
qecScheme - das QEC-Schema (Quantum Error Correction, Quantenfehlerkorrektur)
qubitParams - die physischen Qubit-Parameter
constraints – die Einschränkungen auf Komponentenebene
distillationUnitSpecifications - die Spezifikationen für die Destillationsalgorithmen der T-Fabriken
estimateType - einfach oder grenzüberschreitend

Qubit-Modell ändern

Sie können die Kosten für denselben Algorithmus mithilfe des Majorana-basierten Qubit-Parameters, qubitParams, "qubit_maj_ns_e6" schätzen.

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

Ändern des Quantenfehlerkorrekturschemas

Sie können die Ressourcenabschätzung für dasselbe Beispiel mit den Majorana-basierten QEC-Parametern und einem Floqued-QEC-Schema, qecScheme, wiederholen.

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

Fehlerbudget ändern

Führen Sie als Nächstes den gleichen Quantenkreis mit einem errorBudget-Wert von 10 % erneut aus.

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

Weiter

Übung: Erste Schritte mit der Azure Quantum-Ressourcenschätzung