Oefening: aan de slag met de Azure Quantum Resource Estimator

  • 8 minuten

In de vorige les hebt u geleerd dat de Azure Quantum Resource Estimator werkt door drie hoofdinvoer te gebruiken: de fysieke qubitparameters, het QEC-schema (kwantumfoutcorrectie) en het foutbudget.

Laten we oefenen met de Azure Quantum Resource Estimator. In deze les maakt u een schatting van de fysieke resources van een eenvoudig programma met behulp van de Azure Quantum Resource Estimator.

De vereiste pakketten installeren

Installeer eerst de nieuwste Azure Quantum qsharp en qsharp-widgets pakketten.

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

Het kwantumalgoritmen maken in een Jupyter-notebook

Als u aan de slag wilt gaan met de resource-estimator, maakt u een schatting van de vereiste resources voor een eenvoudig kwantumalgoritmen waarmee een willekeurige bit wordt gegenereerd.

  1. Open Visual Studio Code.

  2. Selecteer opdrachtenpalet > weergeven en selecteer Maken: Nieuwe Jupyter Notebook-.

  3. Importeer het pakket in de eerste cel van het qsharp notebook:

    import qsharp
from qsharp_widgets import EstimateDetails

  4. Voeg een nieuwe cel toe en kopieer de volgende 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;
    }

Het kwantumalgoritmen schatten

Voer nu de resource-estimator uit om de fysieke resources voor de RandomBit-bewerking te schatten. Als u niets opgeeft, gebruikt de resource-estimator de standaardveronderstellingen, dat wil zeggen het qubit_gate_ns_e3 qubitmodel, de surface_code foutcode en het foutenbudget 0,001.

  1. Voeg een nieuwe cel toe en kopieer de volgende code:

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

    De qsharp.estimate functie maakt een resultaatobject, dat kan worden gebruikt om een tabel weer te geven met het totale aantal fysieke resources. In de eerste tabel ziet u de belangrijkste schattingen van fysieke resources. De RandomBit bewerking vereist 300 qubits en duurt twee microseconden om op een kwantumcomputer uit te voeren.

    Schattingen van fysieke resources Weergegeven als
    Runtime 2 microsec
    rQOPS 3.00M
    Fysieke qubits 300

  2. U kunt kostendetails inspecteren door de groepen samen te vouwen, die meer informatie hebben. Vouw bijvoorbeeld de groep logische qubitparameters samen om te zien dat de codeafstand 5 is en het aantal fysieke qubits per logische qubit 50 is.

    Parameter logische qubit Weergegeven als
    QEC-schema surface_code
    Codeafstand 5
    Fysieke qubits 50
    Tijd van logische cyclus 2 microsec
    Foutpercentage logische qubit 3.00E-5
    Kruising vooraf 0.03
    Drempelwaarde voor foutcorrectie 0,01
    Formule voor tijd van logische cyclus (4 * twoQubitGateTime + 2 * oneQubitMeasurementTime) * * codeDistance
    Formule voor fysieke qubits 2 * codeDistance * codeDistance

  3. U kunt het jobParams veld gebruiken voor toegang tot alle doelparameters die kunnen worden doorgegeven aan de taakuitvoering en om te zien welke standaardwaarden zijn aangenomen:

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

    U kunt zien dat de resource-estimator het qubit_gate_ns_e3 qubitmodel, de surface_code foutcode en het foutenbudget 0,001 gebruikt. Dit zijn de standaardwaarden voor de schatting.

De standaardwaarden wijzigen en het algoritme schatten

Als u de standaardwaarden niet wilt gebruiken, kunt u optionele parameters opgeven. We gaan het qubitmodel, het QEC-schema en het foutbudget wijzigen.

Qubitmodel wijzigen

U maakt een schatting van de kosten voor hetzelfde algoritme met behulp van de op Majorana gebaseerde qubitparameter, qubit_maj_ns_e6. Hiervoor moet u de parameter qubitParams doorgeven met het veld name ingesteld op qubit_maj_ns_e6.

Kopieer en voer de volgende code uit in een nieuwe cel:

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

Kwantumfoutcorrectieschema wijzigen

U schat de kosten voor hetzelfde algoritme met de Majorana-gebaseerde qubitparameters met een floqued QEC-schema, qecScheme. Hiervoor moet u ook de parameter qecScheme doorgeven met het veld name ingesteld op floquet_code.

Kopieer en voer de volgende code uit in een nieuwe cel:

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

Foutbudget wijzigen

Maak vervolgens een schatting van de kosten voor dezelfde parameters met een errorBudget van 10%. Hiervoor moet u de parameter errorBudget doorgeven met de waarde ingesteld op 0.1.

Kopieer en voer de volgende code uit in een nieuwe cel:

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

Gefeliciteerd! U hebt de fysieke resources voor een eenvoudig kwantumalgoritmen geschat met behulp van de Azure Quantum Resource Estimator en de parameters aangepast om te zien hoe deze van invloed zijn op de schattingen van resources.

In de volgende les gaat u de moeilijkheidsgraad omhoog tillen en de resources voor het algoritme van Shor schatten met behulp van de Azure Quantum Resource Estimator.