target De parameters van de resource-estimator aanpassen
In dit artikel wordt beschreven hoe u de target parameters van de Azure Quantum Resource Estimator kunt aanpassen aan de machinekenmerken die u wilt instellen. De resource-estimator gebruikt deze parameters om de resources te schatten die nodig zijn om een kwantumalgoritmen uit te voeren op een kwantumcomputer.
Notitie
Als er een probleem optreedt tijdens het werken met de resource-estimator, raadpleegt u de pagina Probleemoplossing.
Vereisten
Een Python-omgeving waarop Python en Pip zijn geïnstalleerd.
De nieuwste versie van Visual Studio Code of open VS Code op het web.
VS Code waarop de Azure Quantum Development Kit, Python en Jupyter-extensies zijn geïnstalleerd.
De nieuwste Azure Quantum
qsharp
enqsharp-widgets
pakketten.python -m pip install --upgrade qsharp qsharp-widgets
Target Parameters
De resource-estimator berekent de schatting van resources, zoals het aantal qubits en de uitvoeringstijd, dat nodig zou zijn om een bepaald kwantumalgoritme te implementeren met behulp van een bepaalde qubit-technologie en met een vaste set architectuurkeuzen.
Daarom gebruikt de resource-estimator een set invoer, met vooraf gedefinieerde waarden om u eenvoudig op weg te helpen:
- Een fysiek qubitmodel, waarmee de eigenschappen van de onderliggende fysieke qubits worden gedefinieerd.
- Een QEC-schema (Quantum Error Correction), het veronderstelde kwantumfoutcorrectieschema.
- Een foutbudget, dat de algemene toegestane fout is, dat wil gezegd, het aantal keren dat het programma niet kan worden gebruikt.
- Beperkingen op onderdeelniveau, het aantal logische cycli en het aantal exemplaren van de T-fabriek.
- Distillatie-eenheden om T factory's destillatiealgoritmen op te geven.
- Pareto grens schatting om meerdere schattingen van het aantal qubits en runtime voor hetzelfde algoritme uit te voeren.
Tip
Als u al een aantal vooraf berekende schattingen voor een bewerking kent, kunt u deze ook opnemen en de uitvoering van de resource-estimator optimaliseren. Zie Hoe u bekende schattingen gebruikt met de resource-estimator voor meer informatie.
Parameters voor fysieke qubits
Wanneer de Resource Estimator de veronderstellingen van fysieke qubits modelleert, worden twee verschillende fysieke instructiesets gebruikt om de qubits te bedienen. De fysieke instructieset kan gate-based of Majorana zijn. Een instructieset op basis van poorten biedt meting van één qubit, enkele qubitpoorten (inclusief T-poorten) en twee qubitpoorten. Een Majorana-instructieset biedt een fysieke T-gate, single-qubit-meting en twee qubit-gezamenlijke meetbewerkingen.
U kunt kiezen uit zes vooraf gedefinieerde qubitparameters, waarvan vier op poorten gebaseerde instructiesets en twee met een Majorana-instructieset. Deze qubitmodellen hebben betrekking op een reeks bewerkingstijden en foutpercentages, waardoor de resourcekosten die nodig zijn voor het inschakelen van praktische kwantumtoepassingen voldoende worden onderzocht.
Qubitparameter | Python-API-klasse | Beschrijving |
---|---|---|
"qubit_gate_ns_e3" , "qubit_gate_ns_e4" |
GATE_NS_E3 , GATE_NS_E4 |
Bewerkingstijden en betrouwbaarheid kunnen overeenkomen met toekomstige versies van supergeleidende transmon-qubits of kring qubits, die doorgaans bewerkingstijden hebben in het nanoseconde-regime. Voor deze qubits worden poort- en meetbewerkingen uitgegaan van respectievelijk 50 ns en 100 ns. Foutpercentages met één qubit en twee qubitpoorten worden verondersteld $10^{-3}$ als realistisch targette zijn 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 betrouwbaarheid 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 worden poort- en meetbewerkingen verondersteld om 100 μs te nemen. Foutpercentage voor single-qubit Clifford-poorten is $10^{-3}$ als realistisch target en $10^{-4}$ als optimistisch target, terwijl de foutpercentage voor niet-Clifford-poorten (T-poort) $ 10^{-6}$ is. Voor poorten met twee qubits is de foutsnelheid $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 betrouwbaarheid kunnen overeenkomen met toekomstige verbeterde versies van Majorana-qubits. Voor deze qubits worden poort- en meetbewerkingen verondersteld om 100 ns te nemen. Om rekening te houden met topologische bescherming in de hardware, worden single-qubit- en twee-qubit-foutpercentages (Clifford-foutpercentages) verondersteld $10^{-4}$ als realistisch targette zijn en $10^{-6}$ als optimistisch target. Niet-Clifford-bewerkingen in deze architectuur hebben geen topologische bescherming, foutpercentage voor fysieke T-poorten van niet-Clifford is 5%. |
Notitie
Tenzij er een andere waarde is opgegeven, is "qubit_gate_ns_e3"
de standaardwaarde voor het qubitmodel.
Parameters voor vooraf gedefinieerde qubitparameters
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 klasse selecteren wanneer u qubitParams
deze uitvoert qsharp.estimate
. 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 een gezamenlijke 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,
},
})
U kunt ook 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 qubits op basis van poort
Python-id | Gegevenstype | Beschrijving |
---|---|---|
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 poort met één qubit ($t_{\rm gate}$) in ns |
two_qubit_gate_time |
tijdtekenreeks | Bewerkingstijd voor twee qubitpoorten in ns |
t_gate_time |
tijdtekenreeks | Bewerkingstijd voor niet-Clifford-poort met één qubit in ns |
one_qubit_measurement_error_rate |
zwevend | Foutpercentage voor meting met één qubit |
one_qubit_gate_error_rate |
zwevend | Foutpercentage voor single-qubit Clifford-poort ($p$) |
two_qubit_gate_error_rate |
zwevend | Foutpercentage voor gate van twee qubit Clifford |
t_gate_error_rate |
zwevend | Foutpercentage voor het voorbereiden van de status single-qubit non-Clifford ($p_T$) |
idle_error_rate |
zwevend | Foutpercentage dat overeenkomt met inactiviteit |
De volgende code laat zien hoe u aangepaste qubitparameters opgeeft voor een instructieset op basis van een poort:
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 two_qubit_gate_error_rate
waarden voor two_qubit_gate_time
en t_gate_time
one_qubit_gate_time
standaard ingesteld op , en one_qubit_gate_error_rate
t_gate_error_rate
de waarde voor idle_error_rate
standaardwaarden ingesteld one_qubit_measurement_error_rate
op .
Qubitparameters voor Majorana-qubits
Python-id | Gegevenstype | Beschrijving |
---|---|---|
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 van twee qubits in ns |
t_gate_time |
tijdtekenreeks | Bewerkingstijd voor niet-Clifford-poort met één qubit in ns |
one_qubit_measurement_error_rate |
zwevend | Foutpercentage voor meting met één qubit |
two_qubit_joint_measurement_error_rate |
zwevend | Foutpercentage voor meting van twee qubits |
t_gate_error_rate |
zwevend | Foutpercentage voor het voorbereiden van de status single-qubit non-Clifford ($p_T$) |
idle_error_rate |
zwevend | 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 dit niet is opgegeven, worden de two_qubit_joint_measurement_error_rate
waarden voor two_qubitJointMeasurementTime
en t_gate_time
one_qubit_measurement_time
standaard ingesteld op , en one_qubit_measurement_error_rate
t_gate_error_rate
de waarde voor idle_error_rate
standaardwaarden ingesteld one_qubit_measurement_error_rate
op .
Voor one_qubit_measurement_error_rate
en two_qubit_joint_measurement_error_rate
, kunt u de foutpercentages opgeven die overeenkomen met metingsleesbewerkingen, readout
en meetverwerking, process
. Deze waarden kunnen getallen of paren 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 foutpercentages met één qubit en twee qubits in majorana-qubitmeting, kunnen zowel de lees- als procesfoutpercentages gelijk zijn.
Belangrijk
Alle waarden die niet zijn opgegeven, nemen bijvoorbeeld een standaardwaarde, waarbij het opgeven een op een poort gebaseerde qubit modelleert "qubit": {"oneQubitGateTime":"200 ns"}
waarin zowel de tijd van de twee qubitpoort als de tijd van de één qubitpoort 200 ns is. Voor eenheden moet u tijdtekenreeksen opgeven, die drijvendekommanummers met dubbele precisie zijn, gevolgd door een spatie en de tijdseenheid voor dergelijke waarden, waar mogelijke tijdachtervoegsels ns
zijn , µs
(of us
), ms
en s
.
Kwantumfoutcorrectieschema's
Als u praktische kwantumtoepassingen wilt uitvoeren, moeten kwantumbewerkingen lage foutpercentages hebben. Deze foutpercentages targets vallen doorgaans buiten de mogelijkheden van onbewerkte fysieke qubits. Om deze beperking te overwinnen, 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 opstellen en een betrouwbaardere logische qubit bouwen die kwantuminformatie beter bewaart dan de onderliggende fysieke qubits.
De resource-estimator gebruikt de volgende formule voor het modelleren van logische foutpercentages met behulp van een exponentiële model,
$$ P = a\left(\frac{p}{p^*}\right)^{\frac{d+1}{2}} $$
waarbij $a$ een kruising vooraf is, is $d$ de codeafstand, $p$ de fysieke foutsnelheid en is $p^*$ de drempelwaarde voor kwantumfoutcorrectie. De kruising vooraf-factor $a$ kan numeriek worden geëxtraheerd voor simulaties.
De codeafstand $d$ is een parameter die het aantal fouten bepaalt dat kan worden gecorrigeerd. Codeafstand definieert dus de foutsnelheid van de logische qubits en het aantal fysieke qubits dat nodig is om ze te coderen. Zowel nauwkeurigheid als het aantal fysieke qubits nemen toe met codeafstand. Het doel van een QEC-schema is om de minimale codeafstand te vinden die de vereiste foutfrequentie voor een bepaalde toepassing kan bereiken.
De fysieke foutsnelheid $p$ wordt geëxtraheerd uit de qubitparameters als de slechtste foutpercentage van een fysieke Clifford-bewerking die op het apparaat wordt uitgevoerd. Met name $p = {}$ max(one_qubit_measurement_error_rate
, one_qubit_gate_error_rate
, ) two_qubit_gate_error_rate
voor qubitparameters met een instructieset op basis van poorten 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 foutpercentages $p^*$ waaronder foutcorrectie fouten onderdrukt.
De Azure Quantum Resource Estimator ondersteunt twee vooraf gedefinieerde QEC-schema's: een surface-code en een floquetcode.
QEC-protocol | Python-API-klasse | Beschrijving |
---|---|---|
"surface_code " |
SURFACE_CODE |
De oppervlaktecode op basis van poorten 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 floquetcode is gebaseerd op arXiv:2202.11829. |
Notitie
Tenzij er een andere waarde is opgegeven, is de standaardwaarde voor het QEC-schema 'surface_code'.
Parameters voor vooraf gedefinieerde QEC-schema's
De exacte parameters voor elk vooraf gedefinieerd QEC-schema zijn het 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 deze uitvoert qsharp.estimate
. Als u bijvoorbeeld de floquetcode wilt selecteren, schrijft u:
qsharp.estimate("RunProgram()", params=
{"qecScheme": {
"name": "floquet_code"
}
})
U kunt ook een lijst met schattingsparameters doorgeven aan de klasse met behulp van de QECScheme
klasse.EstimatorParams
Als u bijvoorbeeld de floquetcode wilt selecteren, schrijft u:
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 kruising vooraf in de floquet-code wilt verhogen, schrijft u:
qsharp.estimate("RunProgram()", params=
{"qecScheme": {
"name": "floquet_code",
"crossingPrefactor": 0.07,
}
})
Notitie
Wanneer dit niet is opgegeven, worden de waarden voor "logicalCycleTime"
en "oneQubitMeasurementTime"
"physicalQubitsPerLogicalQubit"
standaard ingesteld op , de waarde voor "errorCorrectionThreshold"
standaardwaarden 0.01
en de waarde voor "crossingPrefactor"
standaardwaarden .0.03
Uw QEC-schema's aanpassen
De resource-estimator kan een aangepast QEC-schema abstraheren op basis van de bovenstaande formule door waarden op te geven voor de "crossingPrefactor"
$a$ en de "errorCorrectionThreshold"
$p^*$. Verder moet u de tijd opgeven voor het "logicalCycleTime"
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 het "physicalQubitsPerLogicalQubit"
aantal fysieke qubits dat is vereist voor het coderen van één logische qubit 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
, en one_qubit_measurement_time
two_qubit_joint_measurement_time
, waarvan de waarden worden opgehaald uit het corresponderende veld van de fysieke qubitparameters, evenals de variabele eccDistance
voor de codeafstand die is berekend voor de logische qubit, op basis van de fysieke qubiteigenschappen, de drempelwaarde voor foutcorrectie en de kruisingsvoorfactor. De tijdvariabelen en eccDistance
kunnen worden gebruikt om de logicalCycleTime
formule te beschrijven. Voor de formule kan alleen de eccDistance
formule physicalQubitsPerLogicalQubit
worden gebruikt.
Foutbudget
Het totale foutbudget $\epsilon$ stelt de totale getolereerde fout voor het algoritme in, 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 specifiek voor toepassingen.
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 foutbudget nodig zijn voor het oplossen van een probleem met een oplossing, dat niet efficiënt kan worden geverifieerd.
Het foutbudget komt overeen met de som van drie delen:
$$ \epsilon = \epsilon_{\log} + \epsilon_{\rm dis} + \epsilon_{\rm syn} $$
De logische fouten $\epsilon_{\log}$ is de fout bij het implementeren van logische qubits, de T-statusfout $\epsilon_{\rm dis}$ is de fout van het produceren van T-statussen via distillatie en de rotatiepoortfout $\epsilon_{\rm syn}$ is de fout van het synthetiseren van draaipoorten met willekeurige hoeken.
Notitie
Tenzij er een andere waarde is opgegeven, wordt het foutbudget $\epsilon$ uniform verdeeld over de logische fout, T-statusfout en draaipoortfout.
Houd er rekening mee dat voor distillatie- en rotatiesynthese de respectieve foutbudgetten $\epsilon_{\rm dis}$ en $\epsilon_{\rm syn}$ uniform worden verdeeld over alle vereiste T-statussen en alle vereiste draaipoorten. Als het invoeralgoritmen geen draaipoorten bevatten, wordt het foutenbudget uniform verdeeld over logische fouten en T-statusfouten.
Foutbudget doorgeven
Er zijn twee manieren om het foutbudget op te geven door een getal tussen 0 en 1 in te stellen. U kunt het foutbudget doorgeven wanneer het wordt uitgevoerd qsharp.estimate
. Als u bijvoorbeeld een foutbudget van 1/3 wilt selecteren, schrijft u:
qsharp.estimate("RunProgram()", params=
{'errorBudget': 0.333
})
U kunt de foutbudgetparameters ook 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 foutbudget en moet tussen 0 en 1 zijn. Als een kwantumalgoritmen geen T-statussen of rotaties bevatten, zijn de waarden van t_states
respectievelijk rotations
0.
De volgende code laat zien hoe u de parameter voor het foutbudget met T-statussen en rotaties opgeeft:
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 T Factory . Door beperkingen aan te passen, kunt u de schattingen optimaliseren voor het verminderen van het aantal qubits of het verminderen van de runtime.
Parameter | Gegevenstype | Beschrijving |
---|---|---|
logical_depth_factor |
zwevend | 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 verminderen logical_depth_factor , kunt u het aantal aanroepen van de T-fabriek in een bepaalde tijd verhogen, wat resulteert in minder T-fabriekskopieën die nodig zijn om hetzelfde aantal T-statussen te produceren. Wanneer u het aantal T Factory-kopieën vermindert, neemt de algoritmeruntime 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 resources die vereist zijn door het optimale aantal T Factory-kopieën te selecteren waarmee het aantal gebruikte fysieke qubits wordt geminimaliseerd, zonder rekening te houden met de tijdsoverhead. De max_t_factories parameter beperkt het maximum aantal exemplaren en past daarom het aantal logische cycli dienovereenkomstig aan. Zie de 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 of max_physical_qubits beperkingen op het moment, maar niet twee. Als max_duration dit is opgegeven, probeert de resource-estimator de beste schatting te vinden voor max_physical_qubits oplossingen die zijn beperkt door het opgegeven maximumaantal. |
max_physical_qubits |
geheel getal | Maximum aantal fysieke qubits voor het algoritme. De resource-estimator accepteert slechts één van max_duration of max_physical_qubits beperkingen op het moment, maar niet twee. Als max_physical_qubits dit is opgegeven, probeert de resource-estimator de beste schatting te vinden voor max_duration oplossingen die zijn beperkt door het opgegeven maximumaantal. |
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 er geen beperkingen max_duration
of max_physical_qubits
beperkingen zijn opgegeven, is de resource-estimator erop gericht om een oplossing met de kortste tijd te vinden.
Tip
U kunt de oplossingsruimte gebruiken max_duration
en max_physical_qubits
beïnvloeden, mogelijk oplossingen vinden met langere runtime, maar een kleiner aantal qubits vergeleken 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 De schatting van kwantumresources met tijd of aantal qubitsbeperkingen voor meer informatie.
Destillatie-eenheden
U kunt specificaties opgeven voor T factory's destillatiealgoritmen 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 invoer-T-statussen en 1 uitvoer T-status. 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 vergeleken 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"
}
})
Naar verwachting zijn alle numerieke parameters positief. De displayName
geeft aan hoe de distillatie-eenheid wordt weergegeven in uitvoerresultaten.
De volgende code laat zien hoe u de parameters voor de distillatie-eenheid voor een kwantumalgoritmen opgeeft met behulp van de klasse en deProtocolSpecificDistillationUnitSpecification
klasse.DistillationUnitSpecification
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 alsc
.readout_error_rate
, ook aangeduid alsr
.input_error_rate
, ook aangeduid alsz
.
Zie de volgende voorbeelden van aangepaste formules met behulp van 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 vroegere wordt verstrekt, kan de distillatie-eenheid worden toegepast op fysieke qubits. Als alleen de laatste wordt verstrekt, kan de distillatie-eenheid worden toegepast op logische qubits. Als beide worden verstrekt, kan de distillatie-eenheid worden toegepast op beide typen qubits.
De parameter logical_qubit_specification_first_round_override
kan alleen worden opgegeven als logical_qubit_specification
deze is opgegeven. Als dat het geval is, overschrijft het de waarden van logical_qubit_specification
in het geval dat bij de eerste ronde van distillatie wordt toegepast. De waarde <protocol specific parameters>
waarvoor is vereist logical_qubit_specification_first_round_override
, moet het schema volgen:
{
"numUnitQubits": <int>,
"durationInQubitCycleTime": <double>
}
Schatting van paretogrens
Bij het schatten van de resources van een algoritme is het belangrijk om rekening te houden met het verschil tussen het aantal fysieke qubits en de runtime van het algoritme. U kunt overwegen om zoveel mogelijk fysieke qubits toe te kennen 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 de schatting van resources.
De pareto grensraming biedt meerdere schattingen voor hetzelfde algoritme, elk met afwegingen 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 schatting van de grens pareto 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 grensraming wilt visualiseren, kunt u de EstimatesOverview
functie gebruiken. Met deze functies worden de resultaten van de grensraming in een tabel en een tijddiagram weergegeven. Zie het diagram ruimtetijd voor meer informatie.
from qsharp_widgets import EstimatesOverview
EstimatesOverview(result)
Notitie
Als er een probleem optreedt tijdens het werken met de resource-estimator, bekijkt u de pagina Probleemoplossing of neemt u contact op AzureQuantumInfo@microsoft.com.