Verschillende SDK's en IDE's gebruiken met de Resource Estimator

In dit artikel leert u werken met de Azure Quantum Resource Estimator met behulp van verschillende SDK's en ontwikkelomgevingen. In elk voorbeeld worden de schattingen van fysieke resources van een kwantumprogramma targetop een fouttolerante kwantumcomputer geschat en geanalyseerd.

Notitie

De Azure Quantum Resource Estimator wordt momenteel niet ondersteund door de Azure Quantum Development Kit (Modern QDK) Preview . Als u resource-estimatortaken wilt uitvoeren, gebruikt u de Microsoft Quantum Development Kit.

Vereisten

• Een Azure-account met een actief abonnement. Als u geen Azure-account hebt, registreert u zich gratis en meldt u zich aan voor een abonnement op basis van betalen per gebruik.
• Een Azure Quantum-werkruimte. Zie Een Azure Quantum-werkruimte maken voor meer informatie.
• De Microsoft Quantum Computing-provider die is toegevoegd aan uw werkruimte. Zie Enabling the Resource Estimator (Resource estimator inschakelen) targetvoor meer informatie.

De resource-estimator uitvoeren

De Resource Estimator is een target van de Microsoft Quantum Computing-provider. Het gebruik van resource-estimator is precies hetzelfde als het indienen van een taak voor andere software- en hardwareproviders targets in Azure Quantum: definieer uw programma, stel een in targeten dien uw taak in voor berekening. De target_id voor de resource-estimator is microsoft.estimator.

Wanneer u de targetinstelt, kunt u aanvullende optionele parameters opgeven, zoals het qubittype, één qubitpoorttijd, enzovoort. De Resource Estimator retourneert gedetailleerde uitvoer die visueel kan worden weergegeven of programmatisch kan worden geparseerd. Zie Resourceschattingen aanpassen aan machinekenmerken voor meer informatie over invoer- en uitvoerparameters.

• Taaktype: Simulatie (schatting)
• Doel-id: microsoft.estimator

Resourceschatting met Q# en Python

In dit voorbeeld maakt u een algoritme voor kwantumvermenigvuldiging en maakt u een schatting van de kosten op een fouttolerante kwantumcomputer. U gebruikt de azure_quantum API om de resourceschattingstaak te configureren en te verzenden.

Een nieuw notitieblok maken in uw werkruimte

1. Meld u aan bij Azure Portal.
2. Selecteer Notitieblokken in de linkerblade.
3. Klik op Mijn notitieblokken en klik op Nieuwe toevoegen.
4. Selecteer in Kerneltypede optie IPython.
5. Typ een naam voor het bestand en klik op Bestand maken.

Wanneer uw nieuwe notitieblok wordt geopend, wordt automatisch de code voor de eerste cel gemaakt op basis van uw abonnement en werkruimtegegevens.

from azure.quantum import Workspace
workspace = Workspace (
    subscription_id = <your subscription ID>, 
    resource_group = <your resource group>,   
    name = <your workspace name>,          
    location = <your location>        
    )

De vereiste importbewerkingen laden

Eerst moet u resource-estimator selecteren als de target.

Klik op + Code om een nieuwe cel toe te voegen en voeg vervolgens de volgende code toe en voer deze uit:

from azure.quantum.target.microsoft import MicrosoftEstimator, QubitParams
from azure.quantum.target.microsoft.target import MicrosoftEstimatorQubitParams

U importeert ook het qsharp Python-pakket om Q#-code te schrijven in Jupyter-cellen en het Microsoft.Quantum.Numerics pakket dat is vereist voor dit voorbeeld-algoritme. Klik op + Code om een nieuwe cel toe te voegen.

import qsharp
qsharp.packages.add("Microsoft.Quantum.Numerics")

Het kwantumalgoritmen maken

Maak vervolgens een vermenigvuldiger met behulp van de bewerking MultiplyI . U kunt de grootte van de vermenigvuldiger configureren met een bitwidth parameter die kan worden doorgegeven als bewerkingsargument. De EstimateMultiplication bewerking heeft twee invoerregisters, elk de grootte van de opgegeven bitwidth, en één uitvoerregister dat twee keer zo groot is als de opgegeven bitwidth.

Klik op + Code om een nieuwe cel toe te voegen en voeg vervolgens de volgende Q#-code toe met behulp van de magic-opdracht %%qsharp.

%%qsharp

open Microsoft.Quantum.Arithmetic;

operation EstimateMultiplication(bitwidth : Int) : Unit {
    use factor1 = Qubit[bitwidth];
    use factor2 = Qubit[bitwidth];
    use product = Qubit[2 * bitwidth];
    
    MultiplyI(LittleEndian(factor1), LittleEndian(factor2), LittleEndian(product));
}

Notitie

U kunt schattingstaken voor fysieke resources indienen voor algoritmen die geen T-statussen hebben, maar die ten minste één meting hebben.

Het kwantumalgoritmen schatten

Nu maakt u een schatting van de fysieke resources voor deze bewerking met behulp van de standaardveronderstellingen. U kunt de bewerking verzenden naar de Resource Estimator target met behulp van de qsharp.azure.execute functie . Met deze functie wordt de EstimateMultiplication bewerking aangeroepen en wordt het bewerkingsargument doorgegeven bitwidth=8.

result = qsharp.azure.execute(EstimateMultiplication, bitwidth=8)
result

Met de qsharp.azure.execute functie wordt een resultaatobject gemaakt, dat kan worden gebruikt om een tabel weer te geven met het totale aantal fysieke resources. U kunt kostendetails controleren door de groepen samen te vouwen, die meer informatie bevatten.

Tip

Voor een compactere versie van de uitvoertabel kunt u gebruiken result.summary.

Als u bijvoorbeeld de groep logische qubitparameters van de resultatentabel samenvouwt, ziet u dat de afstand van de foutcode 13 is.

Logische qubitparameter	Waarde
QEC-schema	surface_code
Codeafstand	13
Fysieke qubits	338
Logische cyclustijd	5us 200ns
Foutfrequentie logische qubit	3.00E-9
Kruisingsvoorfactor	0.03
Drempelwaarde voor foutcorrectie	0,01
Formule voor logische cyclustijd	(4 * twoQubitGateTime + 2 * oneQubitMeasurementTime) * codeDistance
Formule voor fysieke qubits	2 * codeDistance * codeDistance

In de groep Parameters voor fysieke qubits ziet u de fysieke qubiteigenschappen die voor deze schatting zijn uitgegaan. De tijd voor het uitvoeren van een meting met één qubit en een poort met één qubit wordt bijvoorbeeld uitgegaan van respectievelijk 100 ns en 50 ns.

Tip

U kunt de uitvoer van de Azure Quantum Resources Estimator openen als een Python-woordenlijst met behulp van de result.data() -methode.

Zie de volledige lijst met uitvoergegevens van de Resource Estimator voor meer informatie.

Ruimte-tijddiagrammen

De distributie van fysieke qubits die worden gebruikt voor het algoritme en de T-factory's is een factor die van invloed kan zijn op het ontwerp van uw algoritme. U kunt gebruiken result.diagram.space om deze distributie te visualiseren om meer inzicht te krijgen in de geschatte ruimtevereisten voor het algoritme.

result.diagram.space

Het ruimtediagram toont het aandeel algoritme-qubits en T-factory-qubits. Merk op dat het aantal T factory-kopieën, 15, bijdraagt aan het aantal fysieke qubits voor T factory's als $\text{T factorys} \cdot \text{physical qubit per T factory}= 15 \cdot 9.680 = 145.200$.

U kunt ook de tijd visualiseren die nodig is om het algoritme uit te voeren, de T factory-runtime en hoe vaak de T factory-aanroepen kunnen worden aangeroepen tijdens de runtime van het algoritme. Zie Fysieke schatting van T-factory voor meer informatie.

result.diagram.time

Omdat de T-factoryruntime 57 microsecs is, kan de T-factory in totaal 54 keer worden aangeroepen tijdens de runtime van het algoritme. Eén T-fabriek produceert één T-status en om het algoritme uit te voeren, hebt u in totaal 800 T-statussen nodig. Daarom moet u 15 exemplaren van de T-factory's parallel uitvoeren. Het totale aantal T factory-kopieën wordt berekend als $ \frac{\text{T states} \cdot \text{T factory duration}}{\text{T statussen per T factory} \cdot \text{algorithm runtime}}=\frac{800 \cdot 57.200 \text{ns}}{1 \cdot 3.161.600 \text{ns}}=15$. Houd er rekening mee dat in het diagram elke blauwe pijl de 15 exemplaren van de T-fabriek vertegenwoordigt die 54 keer herhaaldelijk zijn aangeroepen.

Notitie

U kunt de tijd- en ruimtediagrammen in dezelfde cel niet visualiseren.

De standaardwaarden wijzigen en het algoritme schatten

Wanneer u een aanvraag voor een resourceschatting voor uw programma indient, kunt u enkele optionele parameters opgeven. Gebruik het jobParams veld voor toegang tot alle target parameters die kunnen worden doorgegeven aan de taakuitvoering en bekijk 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'}}

Dit zijn de target parameters die kunnen worden aangepast:

• errorBudget - het totale toegestane foutbudget
• qecScheme - het kwantumfoutcorrectieschema (QEC)
• qubitParams - de fysieke qubitparameters
• constraints - de beperkingen op onderdeelniveau
• distillationUnitSpecifications - de specificaties voor de distillatiealgoritmen van de T-fabrieken

Zie Doelparameters voor de resource-estimator voor meer informatie.

Qubitmodel wijzigen

Maak vervolgens een schatting van de kosten voor hetzelfde algoritme met behulp van de op Majorana gebaseerde qubitparameter , qubitParams'qubit_maj_ns_e6'.

result = qsharp.azure.execute(EstimateMultiplication, bitwidth=8, 
            jobParams={
                "qubitParams": {
                    "name": "qubit_maj_ns_e6"
                }})
result

Controleer de fysieke aantallen programmatisch. U kunt bijvoorbeeld alle schattingen van fysieke resources en de uitsplitsing ervan weergeven met behulp van het physicalCounts veld in de resultaatgegevens. Hier leert u welke foutpercentages voor logische qubits en logische T-statussen nodig zijn om overeen te komen met het foutbudget. Runtimes worden standaard weergegeven in nanoseconden.

result['physicalCounts']

{'breakdown': {'adjustedLogicalDepth': 608,
  'cliffordErrorRate': 1e-06,
  'logicalDepth': 608,
  'logicalQubits': 84,
  'numTfactories': 10,
  'numTfactoryRuns': 80,
  'numTsPerRotation': None,
  'numTstates': 800,
  'physicalQubitsForAlgorithm': 4200,
  'physicalQubitsForTfactories': 164160,
  'requiredLogicalQubitErrorRate': 9.790100250626566e-09,
  'requiredLogicalTstateErrorRate': 6.25e-07},
 'physicalQubits': 168360,
 'runtime': 6080000}

U kunt ook details bekijken over de T-factory die is gemaakt om het algoritme uit te voeren.

result['tfactory']

{'eccDistancePerRound': [1, 1, 3],
 'logicalErrorRate': 2.5244447992120037e-07,
 'unitNamePerRound': ['15-to-1 space efficient physical',
  '15-to-1 RM prep physical',
  '15-to-1 RM prep logical'],
 'numInputTstates': 20520,
 'numUnitsPerRound': [1368, 20, 1],
 'numRounds': 3,
 'numTstates': 1,
 'physicalQubits': 16416,
 'physicalQubitsPerRound': [12, 31, 558],
 'runtime': 72900.0,
 'runtimePerRound': [4500.0, 2400.0, 66000.0]}

U kunt deze gegevens gebruiken om uitleg te geven over hoe de T-factory's de vereiste T-statussen produceren.

tfactory = result["tfactory"]
breakdown = result["physicalCounts"]["breakdown"]
producedTstates = breakdown["numTfactories"] * breakdown["numTfactoryRuns"] * tfactory["numTstates"]

print(f"""A single T factory produces {tfactory["numTstates"]} T state(s) with an error rate of {tfactory["logicalErrorRate"]:.2e} (required T state error rate is {breakdown["requiredLogicalTstateErrorRate"]:.2e}).""")
print(f"""{breakdown["numTfactories"]} copie(s) of a T factory are executed {breakdown["numTfactoryRuns"]} time(s) to produce {producedTstates} T states ({breakdown["numTstates"]} are required by the algorithm).""")
print(f"""A single T factory is composed of {tfactory["numRounds"]} rounds of distillation:""")
for round in range(tfactory["numRounds"]):
    print(f"""- {tfactory["numModulesPerRound"][round]} {tfactory["moduleNamePerRound"][round]} unit(s)""")

A single T factory produces 1 T state(s) with an error rate of 2.52e-07 (required T state error rate is 6.25e-07).
10 copie(s) of a T factory are executed 80 time(s) to produce 800 T states (800 are required by the algorithm).
A single T factory is composed of 3 rounds of distillation:
- 1368 15-to-1 space efficient physical unit(s)
- 20 15-to-1 RM prep physical unit(s)
- 1 15-to-1 RM prep logical unit(s)

Correctieschema voor kwantumfouten wijzigen

U kunt de resourceschattingstaak voor hetzelfde voorbeeld opnieuw uitvoeren op de qubitparameters op basis van Majorana met een floqued QEC-schema, qecScheme.

result_maj_floquet = qsharp.azure.execute(EstimateMultiplication, bitwidth=8,
            jobParams={
                "qubitParams": {
                    "name": "qubit_maj_ns_e6"
                },
                "qecScheme": {
                    "name": "floquet_code"
                }})
result_maj_floquet

Foutbudget wijzigen

Voer vervolgens hetzelfde kwantumcircuit opnieuw uit met een errorBudget van 10%.

result_maj_floquet_e1 = qsharp.azure.execute(EstimateMultiplication, bitwidth=8,
            jobParams={
                "qubitParams": {
                    "name": "qubit_maj_ns_e6"
                },
                "qecScheme": {
                    "name": "floquet_code"
                },
                "errorBudget": 0.1})
result_maj_floquet_e1

Geavanceerde analyse van de resultaten van de resourceschatting

Nu u hebt geleerd hoe u schattingen van fysieke resources kunt ophalen en hoe u deze programmatisch kunt openen, kunt u uitgebreidere experimenten uitvoeren. In dit deel evalueert u de kosten voor de op Quantum Fourier Transform gebaseerde vermenigvuldiger voor verschillende bitbreedten, qubitparameters en kwantumfoutcorrectiecodes.

Voeg een nieuwe cel toe en importeer de volgende vereiste pakketten.

import numpy as np                         # To store experimental data from job results
from matplotlib import pyplot as plt       # To plot experimental results
from matplotlib.colors import hsv_to_rgb   # To automatically find colors for plots

Batchverwerking met de resource-estimator

Een resourceschattingstaak bestaat uit twee typen taakparameters: target parameters, dat zijn qubitmodel, QEC-schema's en foutbudget, en optioneel bewerkingsargumenten, dat wil gezegd argumenten die kunnen worden doorgegeven aan het QIR-programma. Met de Azure Quantum Resource Estimator kunt u taken met meerdere configuraties van taakparameters of meerdere items als één taak verzenden om te voorkomen dat meerdere taken opnieuw worden uitgevoerd in hetzelfde kwantumprogramma. Zie Meerdere configuraties uitvoeren als één taak voor meer informatie over batchverwerking.

In het volgende voorbeeld gebruikt u twee van de zes vooraf gedefinieerde qubitparametermodellen en één aangepast model op basis van het model "qubit_gate_ns_e3" (toegankelijk via de constante QubitParams.GATE_NS_E3), waarin u de foutfrequenties instelt op $10^{-3,5}$. Als bewerkingsargumenten kiest u bitbreedten die macht-2 zijn, variërend van 8 tot 64.

estimator = MicrosoftEstimator(workspace=workspace)

# target parameters
target_params = [
    ("Gate-based ns, 10⁻³", MicrosoftEstimatorQubitParams(name=QubitParams.GATE_NS_E3)),
    ("Gate-based ns, 10⁻³ᐧ⁵", MicrosoftEstimatorQubitParams(name=QubitParams.GATE_NS_E3, one_qubit_measurement_error_rate=0.00032, one_qubit_gate_error_rate=0.00032, two_qubit_gate_error_rate=0.00032, t_gate_error_rate=0.00032)),
    ("Gate-based ns, 10⁻⁴", MicrosoftEstimatorQubitParams(name=QubitParams.GATE_NS_E4))
]
# operation arguments
bitwidths = [8, 16, 32, 64]

# This is to access the names of the target parameters
names = [name for (name, _) in target_params]

Notitie

Houd er rekening mee dat target_params een tuple van de naam en de qubitparameter zijn. De qubitparameter is een exemplaar van de klasse MicrosoftEstimatorQubitParams. Het name veld is het enige vereiste veld. De rest van de velden zijn optioneel en worden ingesteld op de standaardwaarden als deze niet zijn opgegeven.

Vervolgens maakt u een batchverwerkingstaak, waarin u voor de Resource Estimator alle combinaties van target_params en bitwidthsmaakt. De bitbreedte wordt toegewezen door deze te openen via het arguments veld van het item. Vervolgens verzendt u de taak met deze items voor het vermenigvuldigingsalgoritmen naar de Azure Quantum Resource Estimator.

params = estimator.make_params(num_items=len(bitwidths) * len(target_params))

for i, (_, target_param) in enumerate(target_params):
    for j, bitwidth in enumerate(bitwidths):
        params.items[i * len(bitwidths) + j].qubit_params = target_param
        params.items[i * len(bitwidths) + j].arguments["bitwidth"] = bitwidth

job = estimator.submit(EstimateMultiplication, input_params=params)
results = job.get_results()

De resultaten uitzetten

Nu u alle resultaten hebt, kunt u er enkele gegevens uit extraheren, zoals het aantal fysieke qubits, de totale runtime in nanoseconden en de QEC-codeafstand voor de logische qubits. Naast het totale aantal fysieke qubits kunt u hun uitsplitsing extraheren in het aantal fysieke qubits voor het uitvoeren van het algoritme en het aantal fysieke qubits dat is vereist voor de T-factory's die de vereiste T-statussen produceren.

qubits = np.zeros((len(names), len(bitwidths), 3))
runtime = np.zeros((len(names), len(bitwidths)))
distances = np.zeros((len(names), len(bitwidths)))

for bitwidth_index, bitwidth in enumerate(bitwidths):
    for name_index, name in enumerate(names):
        # Note that the results are ordered by target parameters first, then by bitwidth
        data = results.data(name_index * len(bitwidths) + bitwidth_index)

        qubits[(name_index, bitwidth_index, 0)] = data['physicalCounts']['physicalQubits']
        qubits[(name_index, bitwidth_index, 1)] = data['physicalCounts']['breakdown']['physicalQubitsForAlgorithm']
        qubits[(name_index, bitwidth_index, 2)] = data['physicalCounts']['breakdown']['physicalQubitsForTfactories']

        runtime[(name_index, bitwidth_index)] = data['physicalCounts']['runtime']

        distances[(name_index, bitwidth_index)] = data['logicalQubit']['codeDistance']

Ten slotte kunt u Matplotlib gebruiken om het aantal fysieke qubits en de runtime als staafplots uit te zetten en de QEC-codeafstanden als een spreidingsdiagram. Voor de fysieke qubits toont de plot de partitie in qubits die vereist zijn voor het algoritme en qubits die zijn vereist voor de T-factory's.

fig, axs = plt.subplots(1, 3, figsize=(22, 6))

num_experiments = len(names)                         # Extract number of experiments form names (can be made smaller)
xs = np.arange(0, len(bitwidths))                    # Map bitwidths to numeric indexes for plotting
full_width = .8                                      # Total width of all bars (should be smaller than 1)
width = full_width / num_experiments                 # Fractional width of a single bar
xs_left = xs - (((num_experiments - 1) * width) / 2) # Starting x-coordinate for bars

# Split axes into qubit and runtime plots
ax_qubits, ax_runtime, ax_code_distance = axs

# Plot physical qubits
for i in range(num_experiments):
    ax_qubits.bar(xs_left + i * width, qubits[i,:,1], width, label=f"{names[i]} (Alg.)", color=hsv_to_rgb((i / num_experiments, 1.0, .8)))
    ax_qubits.bar(xs_left + i * width, qubits[i,:,2], width, bottom=qubits[i,:,1], label=f"{names[i]} (T fac.)", color=hsv_to_rgb((i / num_experiments, 0.3, .8)))
ax_qubits.set_title("#Physical qubits")
ax_qubits.set_xlabel("Bitwidth")
ax_qubits.set_xticks(xs)
ax_qubits.set_xticklabels(bitwidths)
ax_qubits.legend()

# Plot runtime
for i in range(num_experiments):
    ax_runtime.bar(xs_left + i * width, np.array(runtime[i,:]) / 1e6, width, label=names[i], color=hsv_to_rgb((i / num_experiments, 1.0, .8)))
ax_runtime.set_title("Runtime (ms)")
ax_runtime.set_xlabel("Bitwidth")
ax_runtime.set_xticks(xs)
ax_runtime.set_xticklabels(bitwidths)
ax_runtime.legend()

# Plot code distances
for i in range(num_experiments):
    ax_code_distance.scatter(xs, distances[i,:], label=names[i], marker='*', color=hsv_to_rgb((i / num_experiments, 1.0, 0.8)))
ax_code_distance.set_title("QEC code distance")
ax_code_distance.set_xlabel("Bitwidth")
ax_code_distance.set_xticks(xs)
ax_code_distance.set_xticklabels(bitwidths)
ax_code_distance.legend()

fig.suptitle("Resource estimates for multiplication")
plt.show()

Toegang tot de resultatentabel

Het resultaat van de resourceschattingstaak wordt weergegeven in een tabel met meerdere resultaten die afkomstig zijn van de lijst met items. Het maximum aantal items dat moet worden weergegeven, is standaard vijf. Als u een lijst met $N$ items wilt weergeven waarbij $N > 5$, gebruikt u results[0:N].

U ziet dat de items eerst worden geordend op target parameters en vervolgens op bitwidths. Alle items met bitwidth = 8 bevinden zich daarom op indexen ${0, 4, 8}$, items met bitwidth = 16 bevinden zich op indexen ${1, 5, 9}$, items met bitwidth = 32 bevinden zich op indexen ${2, 6, 10}$ en items met bitwidth = 48 bevinden zich op indexen ${3, 7, 11}$. De stapgrootte van 4 komt overeen met het aantal verschillende bitbreedten.

U kunt alle schattingsresultaten voor de breedte van de eerste bit weergeven in een tabel naast elkaar.

bitwidth_index = 0 # items using the first bit width, that is bitwidth = 8
results[bitwidth_index::len(bitwidths)]

U kunt ook toegang krijgen tot afzonderlijke resultaten door een getal op te geven als index. Bijvoorbeeld om results[1] de resultatentabel van de configuratie weer te geven met de eerste set target parameters en bitbreedte 16.

Verder kunt u alle items in het resultaatobject uitzetten met behulp van de plot() functie . Deze functie gebruikt als optionele parameter een matrix met labels voor de legenda van de plot. Hier worden de labels afgeleid van de namen en bitwidths, vergelijkbaar met hoe de items zijn gemaakt.

results.plot(labels=[f"{name} ({bitwidth} bit)" for name in names for bitwidth in bitwidths])

Resourceschatting met Qiskit in Azure Quantum Notebook

In dit voorbeeld maakt u een kwantumcircuit voor een vermenigvuldigingsfunctie op basis van de constructie die wordt weergegeven in Recht-Perez en Garcia-Escartin (arXiv:1411.5949), waarin de Quantum Fourier-transformatie wordt gebruikt om rekenkundige berekeningen te implementeren.

Een nieuw notitieblok maken in uw werkruimte

1. Meld u aan bij de Azure Portal en selecteer uw Azure Quantum-werkruimte.
2. Selecteer onder Bewerkingen de optie Notebooks
3. Klik op Mijn notitieblokken en klik op Nieuwe toevoegen
4. Selecteer in Kerneltypede optie IPython.
5. Typ een naam voor het bestand en klik op Bestand maken.

Wanneer uw nieuwe notitieblok wordt geopend, wordt automatisch de code voor de eerste cel gemaakt op basis van uw abonnement en werkruimtegegevens.

provider = AzureQuantumProvider (
    resource_id = "",
    location = ""
)

De vereiste importbewerkingen laden

Eerst moet u extra modules importeren uit azure-quantum en qiskit.

Klik op + Code om een nieuwe cel toe te voegen en voeg vervolgens de volgende code toe en voer deze uit:

from azure.quantum.qiskit import AzureQuantumProvider
from qiskit import QuantumCircuit, transpile
from qiskit.circuit.library import RGQFTMultiplier
from qiskit.tools.monitor import job_monitor

Maak een back-endexemplaar en stel de Resource Estimator in als uw target.

backend = provider.get_backend('microsoft.estimator')

Het kwantumalgoritmen maken

U kunt de grootte van de vermenigvuldiger aanpassen door de bitwidth variabele te wijzigen. Het genereren van het circuit wordt verpakt in een functie die kan worden aangeroepen met de bitwidth waarde van de vermenigvuldiger. De bewerking heeft twee invoerregisters, elk de grootte van de opgegeven bitwidth, en één uitvoerregister dat tweemaal zo groot is als de opgegeven bitwidth. Met de functie worden ook enkele logische resourcetellingen afgedrukt voor de vermenigvuldigingsfunctie die rechtstreeks uit het kwantumcircuit is geëxtraheerd.

def create_algorithm(bitwidth):
    print(f"[INFO] Create a QFT-based multiplier with bitwidth {bitwidth}")
    
    # Print a warning for large bitwidths that will require some time to generate and
    # transpile the circuit.
    if bitwidth > 18:
        print(f"[WARN] It will take more than one minute generate a quantum circuit with a bitwidth larger than 18")

    circ = RGQFTMultiplier(num_state_qubits=bitwidth, num_result_qubits=2 * bitwidth)

    # One could further reduce the resource estimates by increasing the optimization_level,
    # however, this will also increase the runtime to construct the algorithm.  Note, that
    # it does not affect the runtime for resource estimation.
    print(f"[INFO] Decompose circuit into intrinsic quantum operations")

    circ = transpile(circ, basis_gates=SUPPORTED_INSTRUCTIONS, optimization_level=0)

    # print some statistics
    print(f"[INFO]   qubit count: {circ.num_qubits}")
    print("[INFO]   gate counts")
    for gate, count in circ.count_ops().items():
        print(f"[INFO]   - {gate}: {count}")

    return circ

Notitie

U kunt schattingstaken voor fysieke resources indienen voor algoritmen die geen T-status hebben, maar die ten minste één meting hebben.

Het kwantumalgoritmen schatten

Maak een exemplaar van uw algoritme met behulp van de create_algorithm functie. U kunt de grootte van de vermenigvuldiger aanpassen door de bitwidth variabele te wijzigen.

bitwidth = 4

circ = create_algorithm(bitwidth)

Maak een schatting van de fysieke resources voor deze bewerking met behulp van de standaardveronderstellingen. U kunt het circuit verzenden naar de resource-estimator-back-end met behulp van de run methode en vervolgens uitvoeren job_monitor om te wachten op voltooiing.

job = backend.run(circ)
job_monitor(job)
result = job.result()
result

Hiermee maakt u een tabel met het totale aantal fysieke resources. U kunt kostendetails controleren door de groepen samen te vouwen, die meer informatie bevatten.

Tip

Voor een compactere versie van de uitvoertabel kunt u gebruiken result.summary.

Als u bijvoorbeeld de parametergroep Logische qubit samenvouwt, kunt u gemakkelijker zien dat de afstand van de foutcode 15 is.

Parameter logische qubit	Waarde
QEC-schema	surface_code
Codeafstand	15
Fysieke qubits	450
Logische cyclustijd	6us
Foutfrequentie logische qubit	3.00E-10
Kruisingsvoorfactor	0.03
Drempelwaarde voor foutcorrectie	0,01
Formule voor logische cyclustijd	(4 * twoQubitGateTime + 2 * oneQubitMeasurementTime) * codeDistance
Formule voor fysieke qubits	2 * codeDistance * codeDistance

In de groep Fysieke qubitparameters ziet u de fysieke qubiteigenschappen die voor deze schatting zijn uitgegaan. De tijd voor het uitvoeren van een meting met één qubit en een poort met één qubit wordt bijvoorbeeld uitgegaan van respectievelijk 100 ns en 50 ns.

Tip

U kunt de uitvoer van de resource-estimator ook openen als een Python-woordenlijst met behulp van de result.data() -methode.

Zie de volledige lijst met uitvoergegevens voor de resource-estimator voor meer informatie.

Ruimtetijddiagrammen

De distributie van fysieke qubits die worden gebruikt voor het algoritme en de T-factory's is een factor die van invloed kan zijn op het ontwerp van uw algoritme. U kunt deze distributie visualiseren om meer inzicht te krijgen in de geschatte ruimtevereisten voor het algoritme.

result.diagram.space

In het ruimtediagram ziet u het aandeel algoritme-qubits en T-factory-qubits. Merk op dat het aantal T-factory-kopieën, 28, bijdraagt aan het aantal fysieke qubits voor T-factory's als $\text{T factorys} \cdot \text{fysieke qubit per T-factory}= 28 \cdot 18.000 = 504.000$.

U kunt ook de tijd visualiseren die nodig is om het algoritme uit te voeren, de T Factory-runtime en hoeveel T Factory-aanroepen kunnen worden uitgevoerd tijdens de runtime van het algoritme. Zie Fysieke schatting van de T-fabriek voor meer informatie.

result.diagram.time

Omdat de T factoy runtime 83 microsecs is, kan de T-factory in totaal 543 keer worden aangeroepen tijdens de runtime van het algoritme. Eén T-fabriek produceert één T-status en om de algorihtm uit te voeren, hebt u in totaal 15.180 T-toestanden nodig. Daarom moet u 28 exemplaren van de T-factory's parallel uitvoeren. Het totale aantal T-fabriekskopieën wordt berekend als $ \frac{\text{T states} \cdot \text{T factory duration}}{\text{T statussen per T factory} \cdot \text{algorithm runtime}}=\frac{415,180 \cdot 83,200 \text{ns}}{1 \cdot 45,270,000 \text{ns}}=28$. In het diagram vertegenwoordigt elke blauwe pijl de 28 exemplaren van de T-factory die 543 keer herhaaldelijk zijn aangeroepen.

Notitie

U kunt de tijd- en ruimtediagrammen in dezelfde cel niet visualiseren.

De standaardwaarden wijzigen en het algoritme schatten

Wanneer u een aanvraag voor een resourceschatting voor uw programma indient, kunt u enkele optionele parameters opgeven. Gebruik het jobParams veld om toegang te krijgen tot alle waarden die kunnen worden doorgegeven aan de taakuitvoering en om te zien welke standaardwaarden zijn aangenomen:

result.data()["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'}}

Dit zijn de doelparameters die kunnen worden aangepast:

• errorBudget - het totale toegestane foutbudget
• qecScheme - het kwantumfoutcorrectieschema (QEC)
• qubitParams - de fysieke qubitparameters
• constraints - de beperkingen op onderdeelniveau
• distillationUnitSpecifications - de specificaties voor de distillatiealgoritmen van de T-fabrieken

Zie Doelparameters voor de resource-estimator voor meer informatie.

Qubitmodel wijzigen

Maak vervolgens een schatting van de kosten voor hetzelfde algoritme met behulp van de op Majorana gebaseerde qubitparameter qubit_maj_ns_e6

job = backend.run(circ,
    qubitParams={
        "name": "qubit_maj_ns_e6"
    })
job_monitor(job)
result = job.result()
result

U kunt de fysieke aantallen programmatisch controleren. U kunt bijvoorbeeld alle schattingen van fysieke resources en hun uitsplitsing weergeven met behulp van het physicalCounts veld in de resultaatgegevens. Hiermee worden de foutpercentages voor logische qubits en logische T-status weergegeven die nodig zijn om overeen te komen met het foutbudget. Runtimes worden standaard weergegeven in nanoseconden.

result.data()["physicalCounts"]

{'breakdown': {'adjustedLogicalDepth': 6168,
  'cliffordErrorRate': 1e-06,
  'logicalDepth': 6168,
  'logicalQubits': 45,
  'numTfactories': 23,
  'numTfactoryRuns': 523,
  'numTsPerRotation': 17,
  'numTstates': 12017,
  'physicalQubitsForAlgorithm': 2250,
  'physicalQubitsForTfactories': 377568,
  'requiredLogicalQubitErrorRate': 1.200941538165922e-09,
  'requiredLogicalTstateErrorRate': 2.773848159551746e-08},
 'physicalQubits': 379818,
 'runtime': 61680000}

U kunt ook details bekijken over de T-factory die is gemaakt om het algoritme uit te voeren.

result.data()["tfactory"]

{'eccDistancePerRound': [1, 1, 5],
 'logicalErrorRate': 1.6833177305222897e-10,
 'moduleNamePerRound': ['15-to-1 space efficient physical',
  '15-to-1 RM prep physical',
  '15-to-1 RM prep logical'],
 'numInputTstates': 20520,
 'numModulesPerRound': [1368, 20, 1],
 'numRounds': 3,
 'numTstates': 1,
 'physicalQubits': 16416,
 'physicalQubitsPerRound': [12, 31, 1550],
 'runtime': 116900.0,
 'runtimePerRound': [4500.0, 2400.0, 110000.0]}

U kunt deze gegevens gebruiken om uitleg te geven over hoe de T-factory's de vereiste T-statussen produceren.

data = result.data()
tfactory = data["tfactory"]
breakdown = data["physicalCounts"]["breakdown"]
producedTstates = breakdown["numTfactories"] * breakdown["numTfactoryRuns"] * tfactory["numTstates"]

print(f"""A single T factory produces {tfactory["logicalErrorRate"]:.2e} T states with an error rate of (required T state error rate is {breakdown["requiredLogicalTstateErrorRate"]:.2e}).""")
print(f"""{breakdown["numTfactories"]} copie(s) of a T factory are executed {breakdown["numTfactoryRuns"]} time(s) to produce {producedTstates} T states ({breakdown["numTstates"]} are required by the algorithm).""")
print(f"""A single T factory is composed of {tfactory["numRounds"]} rounds of distillation:""")
for round in range(tfactory["numRounds"]):
    print(f"""- {tfactory["numModulesPerRound"][round]} {tfactory["moduleNamePerRound"][round]} unit(s)""")

A single T factory produces 1.68e-10 T states with an error rate of (required T state error rate is 2.77e-08).
23 copies of a T factory are executed 523 time(s) to produce 12029 T states (12017 are required by the algorithm).
A single T factory is composed of 3 rounds of distillation:
- 1368 15-to-1 space efficient physical unit(s)
- 20 15-to-1 RM prep physical unit(s)
- 1 15-to-1 RM prep logical unit(s)

Correctieschema voor kwantumfouten wijzigen

Voer nu de resourceschattingstaak opnieuw uit voor hetzelfde voorbeeld op de qubitparameters op basis van Majorana met een floqued QEC-schema, qecScheme.

job = backend.run(circ,
    qubitParams={
        "name": "qubit_maj_ns_e6"
    },
    qecScheme={
        "name": "floquet_code"
    })
job_monitor(job)
result_maj_floquet = job.result()
result_maj_floquet

Foutbudget wijzigen

Laten we hetzelfde kwantumcircuit opnieuw uitvoeren met een errorBudget van 10%.

job = backend.run(circ,
    qubitParams={
        "name": "qubit_maj_ns_e6"
    },
    qecScheme={
        "name": "floquet_code"
    },
    errorBudget=0.1)
job_monitor(job)
result_maj_floquet_e1 = job.result()
result_maj_floquet_e1

Resourceschatting met Q# in Visual Studio Code

In dit voorbeeld maakt u een vermenigvuldigingsfunctie en maakt u een schatting van de kosten op een fouttolerante kwantumcomputer.

Vereisten

• Installeer de nieuwste versie van de Quantum Development Kit voor Visual Studio Code.
• Installeer .NET SDK 6.0.
• Installeer de Azure CLI en de quantum CLI-extensie.

Verbinding maken met uw Azure Quantum-werkruimte

1. Open een terminal met toegang tot Azure CLI.

2. Meld u aan bij Azure met uw referenties. U krijgt een lijst met abonnementen die zijn gekoppeld aan uw account.

   az login
   

3. Geef het abonnement op dat u wilt gebruiken van het abonnement dat is gekoppeld aan uw Azure-account. U vindt uw abonnements-id ook in het overzicht van uw werkruimte in Azure Portal.

   az account set -s <Your subscription ID>
   

4. Stel de resourcegroep, werkruimtenaam en locatie in:

   az quantum workspace set -g <resource-group> -w <workspace-name> -l <location> -o table
   

Het kwantumalgoritmen maken

U maakt een vermenigvuldiger met behulp van de bewerking MultiplyI . U kunt de grootte van de vermenigvuldiger configureren met een bitwidth parameter. De bewerking heeft twee invoerregisters, elk de grootte van de opgegeven bitwidth, en één uitvoerregister dat tweemaal zo groot is als de opgegeven bitwidth.

Maak een nieuw project in Visual Studio Code.

1. Selecteer Weergave ->Opdrachtpalet ->Q#: Nieuw project maken.

2. Selecteer Zelfstandige consoletoepassing.

3. Selecteer een locatie om het project op te slaan, geef dit de naam SchattingMeervoudigheid en selecteer Project maken.

4. Wanneer het project is gemaakt, selecteert u Nieuw project openen... in de rechterbenedenhoek. Hiermee worden twee bestanden gegenereerd: het projectbestand EstimateMultiplication.csproj en een Q#-programmasjabloon, Program.qs.

5. Voeg in EstimateMultiplication.csproj, als deze nog niet bestaat, de <verwijzing ItemGroup> toe naar Microsoft.Quantum.Arithmetic:

   <Project Sdk="Microsoft.Quantum.Sdk/X.XX.XXXXXX">
   
     <PropertyGroup>
       <OutputType>Exe</OutputType>
       <TargetFramework>net6.0</TargetFramework>
     </PropertyGroup>
   
     <ItemGroup>
       <PackageReference Include="Microsoft.Quantum.Arithmetic" Version="X.XX.XXXXXX" />
     </ItemGroup>
   
   </Project>
   

6. Vervang de inhoud van het bestand Program.qs door de volgende code:

   namespace QFTmultiplier {
   
       open Microsoft.Quantum.Arithmetic;
   
       @EntryPoint()
       operation EstimateMultiplication() : Unit {
           let bitwidth = 4;
   
           use factor1 = Qubit[bitwidth];
           use factor2 = Qubit[bitwidth];
           use product = Qubit[2 * bitwidth];
   
           MultiplyI(LittleEndian(factor1), LittleEndian(factor2), LittleEndian(product));
       }
   }
   

Notitie

U kunt schattingstaken voor fysieke resources indienen voor algoritmen die geen T-status hebben, maar die ten minste één meting hebben.

Het kwantumalgoritmen schatten

1. Open een terminal met toegang tot Azure CLI.

2. Kopieer de volgende opdracht om een taak naar de resource-estimator targette verzenden.

   az quantum job submit --target-id microsoft.estimator -o json --query id
   

3. De uitvoer bevat de taak-id. Kopieer de taak-id en vraag de uitvoer van de taak aan met behulp -o table van om de uitvoer in de CLI weer te geven als een tabel of met -o json om de uitvoer in JSON-indeling weer te geven.

   az quantum job output -j <job-id> -o table
   

4. In de resulterende tabel ziet u het totale aantal fysieke resources. U kunt kostendetails controleren door de groepen samen te vouwen, die meer informatie bevatten. Als u bijvoorbeeld de groep logische qubitparameters samenvouwt, kunt u gemakkelijker zien dat de afstand van de foutcode 13 is.

Parameter logische qubit	Waarde
QEC-schema	surface_code
Codeafstand	13
Fysieke qubits	338
Logische cyclustijd	5us 200ns
Foutfrequentie logische qubit	3.00E-9
Kruisingsvoorfactor	0.03
Drempelwaarde voor foutcorrectie	0,01
Formule voor logische cyclustijd	(4 * twoQubitGateTime + 2 * oneQubitMeasurementTime) * codeDistance
Formule voor fysieke qubits	2 * codeDistance * codeDistance

In de groep Parameters voor fysieke qubits ziet u de fysieke qubiteigenschappen die voor deze schatting zijn uitgegaan. De tijd voor het uitvoeren van een meting met één qubit en een poort met één qubit wordt bijvoorbeeld uitgegaan van respectievelijk 100 ns en 50 ns.

Fysieke qubitparameter	Waarde
Naam van qubit	qubit_gate_ns_e3
Instructieset	GateBased
Meettijd met één qubit	100 ns
T-poorttijd	50 ns
T-poortfoutpercentage	0,001
Foutpercentage voor meting van één qubit	0,001
Poorttijd met één qubit	50 ns
Foutpercentage met één qubit	0,001
Poorttijd met twee qubits	50 ns
Foutpercentage met twee qubits	0,001

Zie de volledige lijst met uitvoergegevens voor de Resource Estimator voor meer informatie.

De standaardwaarden wijzigen en het algoritme schatten

Wanneer u een aanvraag voor een resourceschatting voor uw programma indient, kunt u enkele optionele parameters opgeven. Er zijn drie invoerparameters op het hoogste niveau die kunnen worden aangepast:

• errorBudget - het totale toegestane foutbudget
• qecScheme - het schema voor kwantumfoutcorrectie (QEC)
• qubitParams - de fysieke qubitparameters

Zie Invoerparameters voor de Resource Estimator voor meer informatie.

Qubitmodel wijzigen

Laten we een schatting maken van de kosten voor hetzelfde algoritme met behulp van de op Majorana gebaseerde qubitparameter , qubitParams'qubit_maj_ns_e6'.

1. Maak een JSON-bestand met de configuratie en geef het jobParams.jsonde naam .

   {
       "qubitParams": {
           "name": "qubit_maj_ns_e6"
       },
   }
   

2. U kunt deze als volgt doorgeven aan het --job-params argument:

   az quantum job submit --target-id microsoft.estimator -o json --query id --job-params "@jobParams.json"
   

3. Inspecteer de tabel opnieuw met -o table.

   az quantum job output -j <job-id> -o table
   

U kunt bijvoorbeeld een uitsplitsing van de schattingen weergeven door op de groep Uitsplitsing te klikken. Hier ziet u welke foutpercentages voor logische qubits en logische T-statussen nodig zijn om overeen te komen met het foutbudget. Runtimes worden standaard weergegeven in nanoseconden.

Name	Waarde
Logische algoritmische qubits	84
Logische algoritmische diepte	608
Aangepaste logische diepte	608
Aantal T-statussen	800
Aantal T-factory's	10
Aantal T factory-aanroepen	80
Fysieke algoritmische qubits	4200
Fysieke T-factory-qubits	164160
Fysieke T-fabrieks qubits (breuk)	97.50 %
Vereiste foutfrequentie logische qubit	9.79e-9
Vereist foutpercentage logische Tstate	6.25e-7
Aantal T-poorten per draaiing	Geen rotaties in algoritme

U kunt ook details bekijken over de T-factory die is gemaakt om het algoritme uit te voeren.

T factory-parameters	Waarde
Fysieke qubits	16416
Runtime	72us 900ns
Aantal T-uitvoerstatussen per uitvoering	1
Aantal T-invoerstatussen per uitvoering	20520
Distillatierondes	3
Destillatie-eenheden per ronde	1368, 20, 1
Distillatie-eenheden	Fysieke 15-op-1 ruimte-efficiënte, fysieke 15-op-1 RM-voorbereiding, 15-op-1 RM-voorbereiding logisch
Destillatiecodeafstanden	1, 1, 3
Aantal fysieke qubits per ronde	12, 31, 558
Runtime per ronde	4us 500ns, 2us 400ns, 66us
Foutpercentage logische T-status	2.52e-07

Eén T-fabriek produceert één T-status. U ziet dat de logische foutfrequentie voor een uitvoer-T-status (2,52e-07) kleiner is dan het vereiste foutpercentage voor de T-status in de uitsplitsing van fysieke aantallen (6,25e-07). De T-fabriek wordt 10 keer gekopieerd, zodat ze parallel kunnen worden uitgevoerd om 10 T-statussen te produceren. Deze kopieën worden 80 keer achter elkaar uitgevoerd en produceren in totaal $10 \cdot 80 = 800$ T statussen die vereist zijn voor het algoritme. Eén T-fabriek bestaat uit drie distillatierondes, waarbij:

• 1368 exemplaren van 15-op-1 ruimte-efficiënte fysieke distillatiemodules werden gebruikt
• 20 exemplaren van 15-op-1 RM prep fysieke distillatiemodules gebruikt
• Er zijn 1 kopieën van 15-op-1 RM-prep logische distillatiemodules gebruikt

Correctieschema voor kwantumfouten wijzigen

Voer nu de resourceschattingstaak voor hetzelfde voorbeeld opnieuw uit op de op Majorana gebaseerde qubitparameters met een floqued QEC-schema, qecScheme.

1. Voeg de parameter voor het kwantumfoutcorrectieschema toe aan het jobParams.json bestand.

   {
       "qubitParams": {
           "name": "qubit_maj_ns_e6"
       },
       "qecScheme": {
         "name": "floquet_code"
       }
   }
   

2. Geef de invoerparameters door aan het --job-params argument.

   az quantum job submit --target-id microsoft.estimator -o json --query id --job-params "@jobParams.json"
   

3. Inspecteer het resultaat met -o table.

   az quantum job output -j <job-id> -o table
   

Foutbudget wijzigen

Voer hetzelfde kwantumcircuit opnieuw uit met een errorBudget van 10%.

1. Voeg de parameter voor het kwantumfoutbudget toe aan het jobParams.json bestand.

   {
       "errorBudget": 0.1,
       "qubitParams": {
           "name": "qubit_maj_ns_e6"
       },
       "qecScheme": {
         "name": "floquet_code"
       }
   }
   

2. Geef de invoerparameters door aan het --job-params argument.

   az quantum job submit --target-id microsoft.estimator -o json --query id --job-params "@jobParams.json"
   

3. Inspecteer het resultaat met -o table.

   az quantum job output -j <job-id> -o table
   

Volgende stappen

• Resourceschattingen aanpassen aan machinekenmerken
• Meer informatie over de werking van resource-estimator
• Haal het meeste uit de Resource Estimator
• Uw eerste resourceschatting uitvoeren
• Zelfstudie: Een QIR-programma verzenden naar de Resource Estimator
• Voorbeeld: Resourceschatting met Q# en VS Code