target De parameters van de resource-estimator aanpassen

  • Artikel

In dit artikel wordt beschreven hoe u de target parameters van de Azure Quantum Resource Estimator kunt aanpassen aan de machinekenmerken die u targetgebruikt. De resource-estimator gebruikt deze parameters om een schatting te maken van de resources die nodig zijn om een kwantumalgoritmen uit te voeren op een kwantumcomputer.

Notitie

Als u een probleem ondervindt tijdens het werken met de resource-estimator, raadpleegt u de pagina Probleemoplossing.

Vereisten

Doelparameters

De Resource Estimator berekent de schatting van resources, zoals het aantal qubits en de uitvoeringstijd, die nodig zou zijn om een bepaald kwantumalgoritme te implementeren met behulp van een bepaalde qubittechnologie en met een vaste set architecturale keuzes.

Daarom gebruikt de resource-estimator een set invoergegevens, met vooraf gedefinieerde waarden om u eenvoudig op weg te helpen:

  • Een fysiek qubitmodel, dat de eigenschappen van de onderliggende fysieke qubits definieert.
  • Een QEC-schema (Quantum Error Correction). Dit is het veronderstelde kwantumfoutcorrectieschema.
  • Een foutbudget, wat de algehele toegestane fout is, dat wil gezegd het aantal keren dat het programma niet kan worden uitgevoerd.
  • Beperkingen op onderdeelniveau, zoals het aantal logische cycli en het aantal T-factory-kopieën.
  • Distillatie-eenheden om de destillatiealgoritmen van T-factory's op te geven.
  • Pareto frontier-schatting om meerdere schattingen van het aantal qubits en runtime uit te voeren voor hetzelfde algoritme.

Fysieke qubitparameters

Wanneer de Resource Estimator de veronderstellingen van fysieke qubits modelleert, worden twee verschillende fysieke instructiesets gebruikt om de qubits uit te voeren. De fysieke instructieset kan gate-based of Majorana zijn. Een instructieset op basis van poorten biedt meting met één qubit, poorten met één qubit (inclusief T-poorten) en poorten met twee qubits. Een Majorana-instructieset biedt een fysieke T-poort, meting met één qubit en twee qubits gezamenlijke meetbewerkingen.

U kunt kiezen uit zes vooraf gedefinieerde qubitparameters, waarvan er vier op gate gebaseerde instructiesets hebben en twee met een Majorana-instructieset. Deze qubit-modellen omvatten een reeks bewerkingstijden en foutpercentages, waardoor voldoende onderzoek mogelijk is van de resourcekosten die nodig zijn om praktische kwantumtoepassingen mogelijk te maken.

Qubit-parameter Python API-klasse Description
"qubit_gate_ns_e3" , "qubit_gate_ns_e4" GATE_NS_E3 , GATE_NS_E4 Bewerkingstijden en -betrouwbaarheiden kunnen overeenkomen met toekomstige versies van supergeleidende transmon-qubits of kring qubits, die doorgaans bewerkingstijden hebben in het nanoseconde-regime. Voor deze qubits wordt ervan uitgegaan dat poort- en meetbewerkingen respectievelijk 50 ns en 100 ns nemen. Foutpercentages voor poorten met één qubit en twee qubits worden als realistisch targetbeschouwd als $10^{-3}$ en $10^{-4}$ als optimistisch target voor een opgeschaald systeem.
"qubit_gate_us_e3" , "qubit_gate_us_e4" GATE_US_E3 , GATE_US_E4 Bewerkingstijden en -betrouwbaarheiden kunnen overeenkomen met toekomstige versies van qubits op basis van ionen, die doorgaans bewerkingstijden hebben in het microseconde-regime. Op basis van typische veronderstellingen voor ion-qubits wordt ervan uitgegaan dat poort- en meetbewerkingen 100 μs nemen. Het foutpercentage voor Clifford-poorten met één qubit is $10^{-3}$ als realistisch target en $10^{-4}$ als optimistisch target, terwijl het foutpercentage voor niet-Clifford-poorten met één qubit (T-poort) $ 10^{-6}$ is. Voor poorten met twee qubits is het foutpercentage $10^{-3}$ als realistisch target en $10^{-4}$ als optimistisch target.
"qubit_maj_ns_e4" , "qubit_maj_ns_e6" MAJ_NS_E4 , MAJ_NS_E6 Bewerkingstijden en -betrouwbaarheiden kunnen overeenkomen met toekomstige verbeterde versies van Majorana-qubits. Voor deze qubits wordt ervan uitgegaan dat poort- en meetbewerkingen 100 ns duren. Als u rekening wilt houden met topologische beveiliging in de hardware, wordt ervan uitgegaan dat de foutpercentages voor samenmeting met één qubit en twee qubits (Clifford-foutpercentages) $10^{-4}$ zijn als een realistische target, en $10^{-6}$ als een optimistische target. Niet-Clifford-bewerkingen in deze architectuur hebben geen topologische beveiliging, het foutpercentage voor niet-Clifford fysieke T-poorten is 5%.

Notitie

Tenzij er een andere waarde is opgegeven, is "qubit_gate_ns_e3"de standaardwaarde voor het qubitmodel .

Ter referentie zijn de volledige vooraf gedefinieerde qubitparameters als volgt:

{
    "qubitParams": {
        "name": "qubit_gate_ns_e3",
        "instructionSet": "GateBased",
        "oneQubitMeasurementTime": "100 ns",
        "oneQubitGateTime": "50 ns",
        "twoQubitGateTime": "50 ns",
        "tGateTime": "50 ns",
        "oneQubitMeasurementErrorRate": 1e-3,
        "oneQubitGateErrorRate": 1e-3,
        "twoQubitGateErrorRate": 1e-3,
        "tGateErrorRate": 1e-3
    }
}

{
    "qubitParams": {
        "name": "qubit_gate_ns_e4",
        "instructionSet": "GateBased",
        "oneQubitMeasurementTime": "100 ns",
        "oneQubitGateTime": "50 ns",
        "twoQubitGateTime": "50 ns",
        "tGateTime": "50 ns",
        "oneQubitMeasurementErrorRate": 1e-4,
        "oneQubitGateErrorRate": 1e-4,
        "twoQubitGateErrorRate": 1e-4,
        "tGateErrorRate": 1e-4
    }
}

{
    "qubitParams": {
        "name": "qubit_gate_us_e3",
        "instructionSet": "GateBased",
        "oneQubitMeasurementTime": "100 µs",
        "oneQubitGateTime": "100 µs",
        "twoQubitGateTime": "100 µs",
        "tGateTime": "100 µs",
        "oneQubitMeasurementErrorRate": 1e-3,
        "oneQubitGateErrorRate": 1e-3,
        "twoQubitGateErrorRate": 1e-3,
        "tGateErrorRate": 1e-6
    }
}

{
    "qubitParams": {
        "name": "qubit_gate_us_e4",
        "instructionSet": "GateBased",
        "oneQubitMeasurementTime": "100 µs",
        "oneQubitGateTime": "100 µs",
        "twoQubitGateTime": "100 µs",
        "tGateTime": "100 µs",
        "oneQubitMeasurementErrorRate": 1e-4,
        "oneQubitGateErrorRate": 1e-4,
        "twoQubitGateErrorRate": 1e-4,
        "tGateErrorRate": 1e-6
    }
}

{
    "qubitParams": {
        "name": "qubit_maj_ns_e4",
        "instructionSet": "Majorana",
        "oneQubitMeasurementTime": "100 ns",
        "twoQubitJointMeasurementTime": "100 ns",
        "tGateTime": "100 ns",
        "oneQubitMeasurementErrorRate": 1e-4,
        "twoQubitJointMeasurementErrorRate": 1e-4,
        "tGateErrorRate": 0.05
    }
}

{
    "qubitParams": {
        "name": "qubit_maj_ns_e6",
        "instructionSet": "Majorana",
        "oneQubitMeasurementTime": "100 ns",
        "twoQubitJointMeasurementTime": "100 ns",
        "tGateTime": "100 ns",
        "oneQubitMeasurementErrorRate": 1e-6,
        "twoQubitJointMeasurementErrorRate": 1e-6,
        "tGateErrorRate": 0.01
    }
}

Vooraf gedefinieerde qubitparameters doorgeven

Er zijn twee manieren om programmatisch vooraf gedefinieerde qubitparameters op te geven. U kunt de naam van het qubitmodel voor de qubitParams klasse selecteren bij het uitvoeren qsharp.estimatevan . Als u bijvoorbeeld de qubitparameter wilt selecteren "qubit_maj_ns_e6" , schrijft u:

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

U kunt de qubitparameters ook doorgeven aan de EstimatorParams klasse met behulp van QubitParams. Als u bijvoorbeeld de qubitparameter wilt selecteren MAJ_NS_E6 , schrijft u:

from qsharp.estimator import EstimatorParams, QubitParams

params = EstimatorParams()
params.qubit_params.name = QubitParams.MAJ_NS_E6 # qubit_maj_ns_e6 qubit parameter

qsharp.estimate("RunProgram()", params=params)

Vooraf gedefinieerde qubitparameters aanpassen

U kunt vooraf gedefinieerde qubitparameters aanpassen door de naam op te geven en vervolgens een van de andere waarden bij te werken. Als u bijvoorbeeld de foutfrequentie van de meting van twee qubits in 'qubit_maj_ns_e4' wilt verlagen, schrijft u:

qsharp.estimate("RunProgram()", params=
                {"qubitParams": {
                        "name": "qubit_maj_ns_e4",
                        "twoQubitJointMeasurementErrorRate": 1e-5,
                    },
                })

Of u kunt de instructies doorgeven in de vorm van een lijst.

from qsharp.estimator import EstimatorParams, QubitParams

params = MicrosoftEstimatorParams()
params.qubit_params.name = QubitParams.MAJ_NS_E4
params.qubit_params.two_qubit_joint_measurement_error_rate = 1e-5

Qubitparameters voor op gate gebaseerde qubits

Python-id Gegevenstype Description
name tekenreeks Naam voor het qubitmodel
instruction_set "gate_based" Onderliggende qubittechnologie
one_qubit_measurement_time tijdtekenreeks Bewerkingstijd voor meting met één qubit ($t_{\rm meas}$) in ns
one_qubit_gate_time tijdtekenreeks Bewerkingstijd voor single-qubit gate ($t_{\rm gate}$) in ns
two_qubit_gate_time tijdtekenreeks Bewerkingstijd voor poort met twee qubits in ns
t_gate_time tijdtekenreeks Bewerkingstijd voor single-qubit niet-Clifford gate in ns
one_qubit_measurement_error_rate float Foutpercentage voor meting met één qubit
one_qubit_gate_error_rate float Foutpercentage voor Clifford-poort met één qubit ($p$)
two_qubit_gate_error_rate float Foutpercentage voor Clifford-poort met twee qubits
t_gate_error_rate float Foutpercentage bij het voorbereiden van een niet-Clifford-status met één qubit ($p_T$)
idle_error_rate float Foutpercentage dat overeenkomt met inactiviteit

De volgende code laat zien hoe u aangepaste qubitparameters opgeeft voor een op gate gebaseerde instructieset:

from qsharp.estimator import EstimatorParams, QubitParams,

params = EstimatorParams()

params.qubit_params.name = "your_custom_name"
params.qubit_params.instruction_set = "gate_based"
params.qubit_params.t_gate_error_rate = 0.03
params.qubit_params.t_gate_time = "10 ns"
params.qubit_params.idle_error_rate = 0.02

Notitie

Wanneer dit niet is opgegeven, worden de waarden voor two_qubit_gate_time en t_gate_time standaard ingesteld op one_qubit_gate_time, de waarden voor two_qubit_gate_error_rate en t_gate_error_rate de standaardwaarden op one_qubit_gate_error_rateen de waarde voor idle_error_rate de standaardwaarden op one_qubit_measurement_error_rate.

Qubitparameters voor Majorana-qubits

Python-id Gegevenstype Description
name tekenreeks Naam voor het qubitmodel
instruction_set "majorana" Onderliggende qubittechnologie
one_qubit_measurement_time tijdtekenreeks Bewerkingstijd voor meting met één qubit ($t_{\rm meas}$) in ns
two-qubit_joint_measurement_time tijdtekenreeks Bewerkingstijd voor meting met twee qubits in ns
t_gate_time tijdtekenreeks Bewerkingstijd voor single-qubit niet-Clifford gate in ns
one_qubit_measurement_error_rate float Foutpercentage voor meting met één qubit
two_qubit_joint_measurement_error_rate float Foutpercentage voor meting met twee qubits
t_gate_error_rate float Foutpercentage bij het voorbereiden van een niet-Clifford-status met één qubit ($p_T$)
idle_error_rate float Foutpercentage dat overeenkomt met inactiviteit

Een minimumsjabloon voor op Majorana gebaseerde instructieset met alle vereiste waarden is:

from qsharp.estimator import EstimatorParams, QubitParams,

params = EstimatorParams()

params.qubit_params.name = "your_custom_name"
params.qubit_params.instruction_set = "majorana"
params.qubit_params.one_qubit_measurement_time = "10 ns"
params.qubit_params.one_qubit_measurement_error_rate = 0.01

Notitie

Wanneer niet wordt opgegeven, worden de waarden voor two_qubitJointMeasurementTime en t_gate_time standaard ingesteld op one_qubit_measurement_time, de waarden voor two_qubit_joint_measurement_error_rate en t_gate_error_rate de standaardwaarden op one_qubit_measurement_error_rateen de waarde voor idle_error_rate de standaardwaarden op one_qubit_measurement_error_rate.

Voor one_qubit_measurement_error_rate en two_qubit_joint_measurement_error_ratekunt u de foutfrequenties opgeven die overeenkomen met meetwaarden, readout, en verwerking van metingen, process. Deze waarden kunnen getallen of paren van getallen zijn <double> . Bijvoorbeeld:

params.qubit_params.two_qubit_joint_measurement_error_rate = \
    MeasurementErrorRate(process=0.00005, readout=0.00007)

Notitie

Als u één numerieke waarde opgeeft voor foutsnelheden met één qubit en twee qubits bij het meten van majorana-qubits, kunnen zowel de lees- als de procesfoutpercentages gelijk zijn.

Belangrijk

Voor alle waarden die niet zijn opgegeven, wordt een standaardwaarde gebruikt. Als u bijvoorbeeld opgeeft, wordt een qubit op basis van een poort gemodelleerd "qubit": {"oneQubitGateTime":"200 ns"} waarin zowel de poorttijd van twee qubits als de poorttijd van één qubit 200 ns is. Voor eenheden moet u tijdreeksen opgeven. Dit zijn getallen met dubbele precisie met drijvende komma, gevolgd door een spatie en de tijdseenheid voor dergelijke waarden. Waar mogelijk zijn nstijdachtervoegsels , µs (of us), en .sms

Kwantumfoutcorrectieschema's

Voor het uitvoeren van kwantumtoepassingen op praktische schaal moeten kwantumbewerkingen lage foutsnelheden hebben. Deze foutfrequentie targets ligt doorgaans buiten de mogelijkheden van onbewerkte fysieke qubits. Om deze beperking te verhelpen, zijn kwantumfoutcorrectie (QEC) en fouttolerante berekeningen twee cruciale technieken die de bouwstenen vormen van grootschalige kwantumcomputers. Ten eerste kunnen we met QEC meerdere foutgevoelige fysieke qubits samenstellen en een betrouwbaardere logische qubit bouwen waarmee kwantumgegevens beter worden bewaard dan de onderliggende fysieke qubits.

De codeafstand voor foutcorrectie (of kortweg codeafstand) is een parameter die het aantal fouten bepaalt dat kan worden gecorrigeerd. Dit is het foutpercentage van de logische qubits en het aantal fysieke qubits dat nodig is om ze te coderen. Zowel de nauwkeurigheid als het aantal fysieke qubits neemt toe met de codeafstand. Het doel is om de minimale codeafstand te vinden waarmee de vereiste foutfrequentie voor een bepaalde toepassing kan worden bereikt.

De Resource Estimator gebruikt de volgende formule voor het modelleren van logische foutpercentages met behulp van een exponentieel model:

$$ P = a\left(\frac{p}{p^*}\right)^{\frac{d+1}{2}} $$

waarbij $d$ de codeafstand is, $p$ het fysieke foutpercentage is en $p^*$ de drempelwaarde voor kwantumfoutcorrectie is. De fysieke foutfrequentie $p$ wordt geëxtraheerd uit de qubitparameters als het slechtste foutpercentage voor elke fysieke Clifford-bewerking in het apparaat.

Met name $p = {}$ max(one_qubit_measurement_error_rate, one_qubit_gate_error_rate, two_qubit_gate_error_rate) voor qubitparameters met een op gate gebaseerde instructieset en $p = {}$ max(one_qubit_measurement_error_rate, two_qubit_joint_measurement_error_rate) voor qubitparameters met een Majorana-instructieset. QEC-schema's hebben doorgaans een drempelwaarde voor het foutenpercentage $p^*$ waaronder foutcorrectie fouten onderdrukt.

QEC-protocol Python API-klasse Description
"surface_code" SURFACE_CODE De op poort gebaseerde surface-code is gebaseerd op arXiv:1208.0928 en arXiv:1009.3686. De Majorana-surfacecode is gebaseerd op arXiv:1909.03002 en arXiv:2007.00307.
"floquet_code" FLOQUET_CODE Alleen voor Majorana-qubits. De floquet-code is gebaseerd op arXiv:2202.11829.

Notitie

Tenzij er een andere waarde is opgegeven, is de standaardwaarde voor het QEC-schema 'surface_code'.

De exacte parameters voor elk vooraf gedefinieerd QEC-schema (inclusief een kruisingsvoorfactor $a$, die numeriek kan worden geëxtraheerd voor simulaties) zijn de volgende.

{
    "qubitParams": {
        "instructionSet": "GateBased",
    }
    "qecScheme": {
        "name": "surface_code",
        "errorCorrectionThreshold": 0.01,
        "crossingPrefactor": 0.03,
        "logicalCycleTime": "(4 * twoQubitGateTime + 2 * oneQubitMeasurementTime) * codeDistance",
        "physicalQubitsPerLogicalQubit": "2 * codeDistance * codeDistance"
    }
}

{
    "qubitParams": {
        "instructionSet": "Majorana",
    }
    "qecScheme": {
        "name": "surface_code",
        "errorCorrectionThreshold": 0.0015,
        "crossingPrefactor": 0.08,
        "logicalCycleTime": "20 * oneQubitMeasurementTime * codeDistance",
        "physicalQubitsPerLogicalQubit": "2 * codeDistance * codeDistance"
    }
}

{
    "qubitParams": {
        "instructionSet": "Majorana",
    }
    "qecScheme": {
        "name": "floquet_code",
        "errorCorrectionThreshold": 0.01,
        "crossingPrefactor": 0.07,
        "logicalCycleTime": "3 * oneQubitMeasurementTime * codeDistance",
        "physicalQubitsPerLogicalQubit": "4 * codeDistance * codeDistance + 8 * (codeDistance - 1)"
    }
}

Vooraf gedefinieerde QEC-schema's doorgeven

Er zijn twee manieren om vooraf gedefinieerde QEC-schema's op te geven. U kunt de naam van het QEC-model voor de "qecScheme" klasse selecteren wanneer u uitvoert qsharp.estimate. Als u bijvoorbeeld de floquetcode wilt selecteren, schrijft u het volgende:

qsharp.estimate("RunProgram()", params=
                {"qecScheme": {
                        "name": "floquet_code"
                    }
                })

U kunt ook een lijst met schattingsparameters doorgeven aan de EstimatorParams klasse met behulp van de QECScheme klasse. Als u bijvoorbeeld de floquetcode wilt selecteren, schrijft u het volgende:

from qsharp.estimator import EstimatorParams, QubitParams, QECScheme,

params = EstimatorParams()
params.items.qec_scheme.name = QECScheme.FLOQUET_CODE # floquet code QEC scheme

qsharp.estimate("RunProgram()", params=params)

Vooraf gedefinieerde QEC-schema's aanpassen

U kunt vooraf gedefinieerde QEC-schema's aanpassen door de naam op te geven en vervolgens een van de andere waarden bij te werken. Als u bijvoorbeeld de kruisingsvoorfactor in de floquetcode wilt verhogen, schrijft u:

qsharp.estimate("RunProgram()", params=
                {"qecScheme": {
                        "name": "floquet_code",
                        "crossingPrefactor": 0.07,
                    }
                })

Notitie

Wanneer niet wordt opgegeven, worden de waarden voor "logicalCycleTime" en "physicalQubitsPerLogicalQubit" standaard ingesteld op "oneQubitMeasurementTime", de waarde voor "errorCorrectionThreshold" de standaardwaarden op 0.01en de waarde voor "crossingPrefactor" de standaardwaarden op 0.03.

Uw QEC-schema's aanpassen

De Resource Estimator kan een aangepast QEC-schema op basis van de bovenstaande formule abstraheren door waarden op te geven voor de "crossingPrefactor" $a$ en de "errorCorrectionThreshold" $p^*$. Verder moet u de "logicalCycleTime"opgeven, dat wil weten de tijd voor het uitvoeren van één logische bewerking, die afhankelijk is van de codeafstand en de veronderstellingen van de fysieke bewerkingstijd van de onderliggende fysieke qubits. Ten slotte berekent een tweede formule de "physicalQubitsPerLogicalQubit", dat wil doen, het aantal fysieke qubits dat nodig is om één logische qubit te coderen op basis van de codeafstand.

U kunt de volgende code gebruiken als sjabloon voor QEC-schema's:

qsharp.estimate("RunProgram()", params=
                {"qecScheme": {
                        "crossingPrefactor": <double>,
                        "errorCorrectionThreshold": <double>,
                        "logicalCycleTime": <formula string>,
                        "physicalQubitsPerLogicalQubit": <formula string>
                    }
                })

In de formules kunt u de variabelen one_qubit_gate_time, two_qubit_gate_time, one_qubit_measurement_timeen two_qubit_joint_measurement_time, gebruiken waarvan de waarden worden opgehaald uit het bijbehorende veld uit de fysieke qubitparameters, evenals de variabele eccDistance voor de codeafstand die is berekend voor de logische qubit, op basis van de fysieke qubit-eigenschappen, de drempelwaarde voor foutcorrectie en de voorfactor voor kruising. De tijdvariabelen en eccDistance kunnen worden gebruikt om de logicalCycleTime formule te beschrijven. Voor de formule physicalQubitsPerLogicalQubit kan alleen de eccDistance worden gebruikt.

Foutbudget

Met het totale foutbudget $\epsilon$ wordt de algehele getolereerde fout voor het algoritme ingesteld, dat wil gezegd, de toegestane foutkans van het algoritme. De globale waarde moet tussen 0 en 1 zijn en de standaardwaarde is 0,001, wat overeenkomt met 0,1%. Met andere woorden, het algoritme mag maximaal één keer in 1000 uitvoeringen mislukken. Deze parameter is zeer toepassingsspecifiek.

Als u bijvoorbeeld het algoritme van Shor uitvoert voor het factoren van gehele getallen, kan een grote waarde voor het foutbudget worden getolereerd, omdat men kan controleren of de uitvoer inderdaad de belangrijkste factoren van de invoer zijn. Aan de andere kant kan een kleiner foutenbudget nodig zijn voor een algoritme dat een probleem oplost met een oplossing, wat niet efficiënt kan worden geverifieerd.

Het foutenbudget komt overeen met de som van drie delen:

$$ \epsilon = \epsilon_{\log} + \epsilon_{\rm dis} + \epsilon_{\rm syn} $$

Als niet verder wordt opgegeven, wordt het foutbudget $\epsilon$ uniform gedistribueerd en is het van toepassing op fouten $\epsilon_{\log}$ voor het implementeren van logische qubits, produceert het foutbudget $\epsilon_{\rm dis}$ T-statussen via distillatie en een foutbudget $\epsilon_{\rm syn}$ om draaipoorten met willekeurige hoeken te synthetiseren.

Houd er rekening mee dat voor distillatie- en rotatiesynthese de respectieve foutbudgetten $\epsilon_{\rm dis}$ en $\epsilon_{\rm syn}$ uniform zijn verdeeld over alle vereiste T-statussen en alle vereiste draaipoorten. Als het invoeralgoritmen geen draaipoorten bevat, wordt het foutbudget gelijkmatig verdeeld over logische fouten en T-statusfouten.

Budget voor fout doorgeven

Er zijn twee manieren om het foutbudget op te geven door een getal in te stellen tussen 0 en 1. U kunt het foutbudget doorgeven bij het uitvoeren van qsharp.estimate. Als u bijvoorbeeld een foutbudget van 1/3 wilt selecteren, schrijft u:

qsharp.estimate("RunProgram()", params=
                {'errorBudget': 0.333
                })

U kunt ook de foutbudgetparameters doorgeven aan de EstimatorParams klasse.

from qsharp.estimator import EstimatorParams, QubitParams, QECScheme,

params = EstimatorParams()
params.items.error_budget = 0.333 # error budget of 1/3

qsharp.estimate("RunProgram()", params=params)

U kunt ook elk onderdeel van het foutbudget afzonderlijk opgeven. De som van alle waarden is het totale foutenbudget en moet tussen 0 en 1 zijn. Als een kwantumalgoritmen geen T-statussen of -rotaties bevatten, kunnen de waarden van t_states en rotations respectievelijk 0 zijn.

De volgende code laat zien hoe u de foutparameter budget opgeeft met T-statussen en rotaties:

from qsharp.estimator import EstimatorParams, QubitParams,

params = EstimatorParams()
params.error_budget.logical = 0.01
params.error_budget.t_states = 0.02
params.error_budget.rotations = 0.03

Beperkingen

U kunt de "constraints" klasse gebruiken om beperkingen toe te passen op het onderdeelniveau van de T-factory . Door beperkingen aan te passen, kunt u de schattingen optimaliseren om het aantal qubits te verminderen of de runtime te verminderen.

Parameter Gegevenstype Beschrijving
logical_depth_factor float De uitvoeringstijd beheren. Als de waarde groter is dan 1, wordt het eerste aantal logische cycli, ook wel logische diepte genoemd, vermenigvuldigd met dit getal. Door te verlagen logical_depth_factor, kunt u het aantal aanroepen van de T-fabriek in een bepaalde tijd verhogen, waardoor er minder T-fabriekskopieën nodig zijn om hetzelfde aantal T-statussen te produceren. Wanneer u het aantal T factory-kopieën vermindert, neemt de runtime van het algoritme dienovereenkomstig toe. De schaalfactor voor de totale runtime kan groter zijn, omdat het vereiste logische foutpercentage toeneemt vanwege het extra aantal cycli.
max_t_factories geheel getal Maximum aantal T-fabriekskopieën. De Resource Estimator bepaalt de benodigde resources door het optimale aantal T factory-kopieën te selecteren dat het aantal gebruikte fysieke qubits minimaliseert, zonder rekening te houden met de tijdsoverhead. De max_t_factories parameter beperkt het maximum aantal kopieën en past daarom het aantal logische cycli dienovereenkomstig aan. Zie Fysieke schatting van T-factory voor meer informatie.
max_duration tijdtekenreeks Maximale runtime voor het algoritme. De resource-estimator accepteert slechts één van max_duration de beperkingen of max_physical_qubits op dat moment, maar niet twee. Als max_duration is opgegeven, probeert de resource-estimator de beste schatting te vinden voor max_physical_qubits oplossingen die worden beperkt door het maximale aantal dat is opgegeven.
max_physical_qubits geheel getal Maximum aantal fysieke qubits voor het algoritme. De resource-estimator accepteert slechts één van max_duration de beperkingen of max_physical_qubits op dat moment, maar niet twee. Als max_physical_qubits is opgegeven, probeert de resource-estimator de beste schatting te vinden voor max_duration oplossingen die worden beperkt door het maximale aantal dat is opgegeven.

De volgende code laat zien hoe u de beperkingen voor een kwantumalgoritmen opgeeft:

from qsharp.estimator import EstimatorParams

params = EstimatorParams()

params.constraints.max_duration = "1 s"
params.constraints.logical_depth_factor = 1.5
params.constraints.max_t_factories = 10

Notitie

Als de waarde die is opgegeven aan max_duration of max_physical_qubits te klein is om een haalbare oplossing te vinden, retourneert de resource-estimator een fout. Als geen van beide max_durationmax_physical_qubits beperkingen zijn opgegeven, probeert de resource-estimator een oplossing te vinden met de kortste tijd.

Tip

U kunt en max_physical_qubits gebruiken max_duration om de oplossingsruimte te beïnvloeden en mogelijk oplossingen te vinden met een langere runtime, maar een kleiner aantal qubits in vergelijking met oplossingen zonder deze beperkingen. Er bestaat een afweging tussen runtime en het aantal qubits, en deze afweging kan efficiënt worden beheerd voor sommige algoritmen, met verschillende effecten op verschillende algoritmen. Tabel IV in [arXiv:2211.07629] illustreert het effectieve gebruik van de afweging tussen het aantal qubits en runtime voor kwantumdynamische algoritmen. Zie Kwantumresourceschatting met een voorbeeld van beperkingen voor tijd of aantal qubits voor meer informatie.

Distillatie-eenheden

U kunt specificaties opgeven voor de distillatiealgoritmen van T-factory's met de DistillationUnitSpecification klasse . De specificatie kan vooraf gedefinieerd of aangepast zijn. U kunt een vooraf gedefinieerde specificatie opgeven door de naam van de distillatie-eenheid te selecteren: 15-1 RM of 15-1 space-efficient.

from qsharp.estimator import EstimatorParams, DistillationUnitSpecification

params = EstimatorParams()
unit = DistillationUnitSpecification()
unit.name = "15-1 RM" # predefined distillation unit

params.distillation_unit_specifications.append(unit)

In beide gevallen staat notatie 15-1 voor 15 T-invoerstatussen en 1 T-uitvoerstatus. De 15-1 space-efficient distillatie-eenheid gebruikt minder qubits dan 15-1 RM , maar vereist meer runtime. Zie Tabel VI voor meer informatie.

Tip

Het gebruik van vooraf gedefinieerde distillatie-eenheden biedt betere prestaties in vergelijking met aangepaste eenheden.

Uw distillatie-eenheden aanpassen

U kunt uw eigen distillatie-eenheden aanpassen. De exacte parameters voor de distillatie-eenheden zijn de volgende.

qsharp.estimate("RunProgram()", params=
                    {"distillationUnitSpecifications": {
                        "displayName": <string>, 
                        "numInputTs": <int>,
                        "numOutputTs": <int>,
                        "failureProbabilityFormula": <string>,
                        "outputErrorRateFormula": <string>,
                        "physicalQubitSpecification": <protocol specific parameters>, 
                        "logicalQubitSpecification": <protocol specific parameters>, 
                        "logicalQubitSpecificationFirstRoundOverride": <protocol specific parameters>, # Only if "logicalQubitSpecification"
                        }
                })

Alle numerieke parameters zijn naar verwachting positief. De displayName geeft aan hoe de distillatie-eenheid wordt weergegeven in de uitvoerresultaten.

De volgende code laat zien hoe u de distillatie-eenheidparameters voor een kwantumalgoritmen opgeeft met behulp van de DistillationUnitSpecification klasse en de ProtocolSpecificDistillationUnitSpecification klasse.

from qsharp.estimator import EstimatorParams, DistillationUnitSpecification, ProtocolSpecificDistillationUnitSpecification

params = EstimatorParams()
unit = DistillationUnitSpecification()
unit.display_name = "T"
unit.failure_probability_formula = "c"
unit.output_error_rate_formula = "r"
unit.num_input_ts = 1
unit.num_output_ts = 2

physical_qubit_specification = ProtocolSpecificDistillationUnitSpecification()
physical_qubit_specification.num_unit_qubits = 1
physical_qubit_specification.duration_in_qubit_cycle_time = 2
unit.physical_qubit_specification = physical_qubit_specification

De formules voor failure_probability_formula en output_error_rate_formula zijn aangepaste formules met eenvoudige rekenkundige bewerkingen, constanten en slechts drie parameters:

  • clifford_error_rate, ook aangeduid als c.
  • readout_error_rate, ook aangeduid als r.
  • input_error_rate, ook aangeduid als z.

Bekijk de volgende voorbeelden van aangepaste formules met lange en korte notatie. Deze voorbeelden illustreren formules die standaard worden gebruikt in de standaard implementatie.

Parameter Lange formule Korte formule
failure_probability_formula "15,0 * input_error_rate + 356,0 * clifford_error_rate" "15,0 * z + 356,0 * c"
output_error_rate_formula "35,0 * input_error_rate ^ 3 + 7,1 * clifford_error_rate" "35,0 * z ^ 3 + 7,1 * c"

Ten minste één van de parameters physical_qubit_specification of logical_qubit_specification moet worden opgegeven. Als alleen de eerste is opgegeven, kan de destillatie-eenheid worden toegepast op fysieke qubits. Als alleen de laatste is opgegeven, kan de destillatie-eenheid worden toegepast op logische qubits. Als beide worden opgegeven, kan de destillatie-eenheid worden toegepast op beide typen qubits.

De parameter logical_qubit_specification_first_round_override kan alleen worden opgegeven als logical_qubit_specification is opgegeven. Als dit het geval is, worden de waarden van in het geval van logical_qubit_specification toepassing bij de eerste distillatieronde overschreven. De waarde <protocol specific parameters> die is vereist voor logical_qubit_specification_first_round_override , moet het schema volgen:

{
    "numUnitQubits": <int>,
    "durationInQubitCycleTime": <double>
}

Pareto grensschatting

Bij het schatten van de resources van een algoritme is het belangrijk om rekening te houden met de afweging tussen het aantal fysieke qubits en de runtime van het algoritme. U kunt overwegen om zoveel mogelijk fysieke qubits toe te passen om de runtime van het algoritme te verminderen. Het aantal fysieke qubits wordt echter beperkt door het aantal fysieke qubits dat beschikbaar is in de kwantumhardware. Inzicht in de balans tussen runtime en systeemschaal is een van de belangrijkste aspecten van resourceschatting.

De Pareto frontier-schatting biedt meerdere schattingen voor hetzelfde algoritme, waarbij elk een afweging laat zien tussen het aantal qubits en de runtime.

Notitie

Als u de resource-estimator in Visual Studio Code uitvoert met behulp van de Q#optie : Resourceschattingen berekenen , is de pareto-grensschatting standaard ingeschakeld.

Als u de Resource Estimator uitvoert in Python, moet u de "estimateType" parameter opgeven als "frontier".

result = qsharp.estimate("RunProgram()", params=
                    {"qubitParams": { "name": "qubit_maj_ns_e4" },
                    "qecScheme": { "name": "surface_code" },
                    "estimateType": "frontier", # Pareto frontier estimation
                    }
                )

Als u de resultaten van pareto grensschatting wilt visualiseren, kunt u de EstimatesOverview functie gebruiken. Met deze functie worden de resultaten van grensschatting weergegeven in tabel en een ruimtetijddiagram. Zie Ruimte-tijddiagram voor meer informatie.

from qsharp_widgets import EstimatesOverview

EstimatesOverview(result)

Notitie

Als u een probleem ondervindt tijdens het werken met de resource-estimator, gaat u naar de pagina Probleemoplossing of neemt u contact op met AzureQuantumInfo@microsoft.com.

Volgende stappen